import { ATN } from "antlr4ts/atn/ATN";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { RuleContext } from "antlr4ts/RuleContext";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { FlinkSQLParserListener } from "./FlinkSQLParserListener";
import { FlinkSQLParserVisitor } from "./FlinkSQLParserVisitor";
export declare class FlinkSQLParser extends Parser {
    static readonly SPACE = 1;
    static readonly BLOCK_COMMENT = 2;
    static readonly LINE_COMMENT = 3;
    static readonly L_HINT = 4;
    static readonly R_HINT = 5;
    static readonly L_BRACE_SLASH = 6;
    static readonly R_BRACE_SLASH = 7;
    static readonly STAR_QUESTION = 8;
    static readonly PLUS_QUESTION = 9;
    static readonly QUESTION_QUESTION = 10;
    static readonly DOUBLE_VERTICAL_BAR = 11;
    static readonly COMPOUND_ARROW = 12;
    static readonly DOT = 13;
    static readonly COLON = 14;
    static readonly COMMA = 15;
    static readonly SEMICOLON = 16;
    static readonly VERTICAL_BAR = 17;
    static readonly DOLLAR_SIGN = 18;
    static readonly CARET = 19;
    static readonly QUESTION = 20;
    static readonly PLUS = 21;
    static readonly SLASH = 22;
    static readonly ASTERISK = 23;
    static readonly DIVIDE = 24;
    static readonly PERCENTAGE = 25;
    static readonly SINGLE_QUOTE = 26;
    static readonly DOUBLE_QUOTE = 27;
    static readonly BACK_QUOTE = 28;
    static readonly UNDERLINE = 29;
    static readonly L_PARENTHESIS = 30;
    static readonly R_PARENTHESIS = 31;
    static readonly L_BRACKET = 32;
    static readonly R_BRACKET = 33;
    static readonly L_BRACE = 34;
    static readonly R_BRACE = 35;
    static readonly EQUAL = 36;
    static readonly DOUBLE_EQUAL = 37;
    static readonly NOT_EQUAL = 38;
    static readonly IS_EQUAL_NULL = 39;
    static readonly UNEQUAL = 40;
    static readonly GREATER = 41;
    static readonly GREATER_OR_EQUAL = 42;
    static readonly LESS = 43;
    static readonly LESS_OR_EQUAL = 44;
    static readonly ABS = 45;
    static readonly ALL = 46;
    static readonly ALLOCATE = 47;
    static readonly ALLOW = 48;
    static readonly ALTER = 49;
    static readonly AND = 50;
    static readonly K_ANY = 51;
    static readonly ARE = 52;
    static readonly ARRAY = 53;
    static readonly ARRAY_MAX_CARDINALITY = 54;
    static readonly AS = 55;
    static readonly ASENSITIVE = 56;
    static readonly ASYMMETRIC = 57;
    static readonly AT = 58;
    static readonly ATOMIC = 59;
    static readonly AUTHORIZATION = 60;
    static readonly AUTO = 61;
    static readonly AVG = 62;
    static readonly BEGIN = 63;
    static readonly BEGIN_FRAME = 64;
    static readonly BEGIN_PARTITION = 65;
    static readonly BETWEEN = 66;
    static readonly BIGINT = 67;
    static readonly BINARY = 68;
    static readonly BIT = 69;
    static readonly BLOB = 70;
    static readonly BOOLEAN = 71;
    static readonly BOTH = 72;
    static readonly BUCKETS = 73;
    static readonly BY = 74;
    static readonly CALL = 75;
    static readonly CALLED = 76;
    static readonly CARDINALITY = 77;
    static readonly CASCADED = 78;
    static readonly CASE = 79;
    static readonly CAST = 80;
    static readonly CEIL = 81;
    static readonly CEILING = 82;
    static readonly CHANGELOG_MODE = 83;
    static readonly CHAR = 84;
    static readonly CHARACTER = 85;
    static readonly CHARACTER_LENGTH = 86;
    static readonly CHAR_LENGTH = 87;
    static readonly CHECK = 88;
    static readonly CLASSIFIER = 89;
    static readonly CLOB = 90;
    static readonly CLOSE = 91;
    static readonly COALESCE = 92;
    static readonly COLLATE = 93;
    static readonly COLLECT = 94;
    static readonly COLUMN = 95;
    static readonly COMMIT = 96;
    static readonly CONDITION = 97;
    static readonly CONNECT = 98;
    static readonly CONSTRAINT = 99;
    static readonly CONTAINS = 100;
    static readonly CONTINUOUS = 101;
    static readonly CONVERT = 102;
    static readonly CORR = 103;
    static readonly CORRESPONDING = 104;
    static readonly COUNT = 105;
    static readonly COVAR_POP = 106;
    static readonly COVAR_SAMP = 107;
    static readonly CREATE = 108;
    static readonly CROSS = 109;
    static readonly CUBE = 110;
    static readonly CUME_DIST = 111;
    static readonly CURRENT = 112;
    static readonly CURRENT_CATALOG = 113;
    static readonly CURRENT_DATE = 114;
    static readonly CURRENT_DEFAULT_TRANSFORM_GROUP = 115;
    static readonly CURRENT_PATH = 116;
    static readonly CURRENT_ROLE = 117;
    static readonly CURRENT_ROW = 118;
    static readonly CURRENT_SCHEMA = 119;
    static readonly CURRENT_TIME = 120;
    static readonly CURRENT_TIMESTAMP = 121;
    static readonly CURRENT_TRANSFORM_GROUP_FOR_TYPE = 122;
    static readonly CURRENT_USER = 123;
    static readonly CURSOR = 124;
    static readonly CYCLE = 125;
    static readonly DATE = 126;
    static readonly DAY = 127;
    static readonly DEALLOCATE = 128;
    static readonly DEC = 129;
    static readonly DECIMAL = 130;
    static readonly DECLARE = 131;
    static readonly DEFAULT = 132;
    static readonly DEFINE = 133;
    static readonly DELETE = 134;
    static readonly DENSE_RANK = 135;
    static readonly DEREF = 136;
    static readonly DESCRIBE = 137;
    static readonly DETERMINISTIC = 138;
    static readonly DISALLOW = 139;
    static readonly DISCONNECT = 140;
    static readonly DISTINCT = 141;
    static readonly DISTRIBUTED = 142;
    static readonly DISTRIBUTION = 143;
    static readonly DOUBLE = 144;
    static readonly DROP = 145;
    static readonly DYNAMIC = 146;
    static readonly EACH = 147;
    static readonly ELEMENT = 148;
    static readonly ELSE = 149;
    static readonly EMPTY = 150;
    static readonly END = 151;
    static readonly END_EXEC = 152;
    static readonly END_FRAME = 153;
    static readonly END_PARTITION = 154;
    static readonly EQUALS = 155;
    static readonly ESCAPE = 156;
    static readonly ESTIMATED_COST = 157;
    static readonly EVERY = 158;
    static readonly EXCEPT = 159;
    static readonly EXEC = 160;
    static readonly EXECUTE = 161;
    static readonly EXISTS = 162;
    static readonly EXP = 163;
    static readonly EXPLAIN = 164;
    static readonly EXTEND = 165;
    static readonly EXTERNAL = 166;
    static readonly EXTRACT = 167;
    static readonly FALSE = 168;
    static readonly FETCH = 169;
    static readonly FILTER = 170;
    static readonly FIRST_VALUE = 171;
    static readonly FLOAT = 172;
    static readonly FLOOR = 173;
    static readonly FOR = 174;
    static readonly FOREIGN = 175;
    static readonly FRAME_ROW = 176;
    static readonly FREE = 177;
    static readonly FRESHNESS = 178;
    static readonly FROM = 179;
    static readonly FULL = 180;
    static readonly FUNCTION = 181;
    static readonly FUSION = 182;
    static readonly GAP = 183;
    static readonly GET = 184;
    static readonly GLOB = 185;
    static readonly GLOBAL = 186;
    static readonly GRANT = 187;
    static readonly GROUP = 188;
    static readonly GROUPING = 189;
    static readonly GROUPS = 190;
    static readonly HAVING = 191;
    static readonly HOLD = 192;
    static readonly HOUR = 193;
    static readonly IDENTITY = 194;
    static readonly IMPORT = 195;
    static readonly IN = 196;
    static readonly INDICATOR = 197;
    static readonly INITIAL = 198;
    static readonly INNER = 199;
    static readonly INOUT = 200;
    static readonly INSENSITIVE = 201;
    static readonly INSERT = 202;
    static readonly INT = 203;
    static readonly INTEGER = 204;
    static readonly INTERSECT = 205;
    static readonly INTERSECTION = 206;
    static readonly INTERVAL = 207;
    static readonly INTO = 208;
    static readonly IS = 209;
    static readonly JOIN = 210;
    static readonly JSON_ARRAY = 211;
    static readonly JSON_ARRAYAGG = 212;
    static readonly JSON_EXECUTION_PLAN = 213;
    static readonly JSON_EXISTS = 214;
    static readonly JSON_OBJECT = 215;
    static readonly JSON_OBJECTAGG = 216;
    static readonly JSON_QUERY = 217;
    static readonly JSON_VALUE = 218;
    static readonly LAG = 219;
    static readonly LANGUAGE = 220;
    static readonly LARGE = 221;
    static readonly LAST_VALUE = 222;
    static readonly LATERAL = 223;
    static readonly LEAD = 224;
    static readonly LEADING = 225;
    static readonly LEFT = 226;
    static readonly LIKE = 227;
    static readonly LIKE_REGEX = 228;
    static readonly LIMIT = 229;
    static readonly LN = 230;
    static readonly LOCAL = 231;
    static readonly LOCALTIME = 232;
    static readonly LOCALTIMESTAMP = 233;
    static readonly LOWER = 234;
    static readonly MATCH = 235;
    static readonly MATCHES = 236;
    static readonly MATCH_NUMBER = 237;
    static readonly MATCH_RECOGNIZE = 238;
    static readonly MATERIALIZED = 239;
    static readonly MAX = 240;
    static readonly MEASURES = 241;
    static readonly MEMBER = 242;
    static readonly MERGE = 243;
    static readonly METHOD = 244;
    static readonly MIN = 245;
    static readonly MINUS = 246;
    static readonly MINUTE = 247;
    static readonly MOD = 248;
    static readonly MODIFIES = 249;
    static readonly MODULE = 250;
    static readonly MONTH = 251;
    static readonly MULTISET = 252;
    static readonly NATIONAL = 253;
    static readonly NATURAL = 254;
    static readonly NCHAR = 255;
    static readonly NCLOB = 256;
    static readonly NEW = 257;
    static readonly NEXT = 258;
    static readonly NO = 259;
    static readonly NONE = 260;
    static readonly NORMALIZE = 261;
    static readonly NOT = 262;
    static readonly NTH_VALUE = 263;
    static readonly NTILE = 264;
    static readonly NULL = 265;
    static readonly NULLIF = 266;
    static readonly NUMERIC = 267;
    static readonly OCCURRENCES_REGEX = 268;
    static readonly OCTET_LENGTH = 269;
    static readonly OF = 270;
    static readonly OFFSET = 271;
    static readonly OLD = 272;
    static readonly OMIT = 273;
    static readonly ON = 274;
    static readonly ONE = 275;
    static readonly ONLY = 276;
    static readonly OPEN = 277;
    static readonly OPTIMIZE = 278;
    static readonly OR = 279;
    static readonly ORDER = 280;
    static readonly OUT = 281;
    static readonly OUTER = 282;
    static readonly OVER = 283;
    static readonly OVERLAPS = 284;
    static readonly OVERLAY = 285;
    static readonly PARAMETER = 286;
    static readonly PARTITION = 287;
    static readonly PATTERN = 288;
    static readonly PER = 289;
    static readonly PERCENT = 290;
    static readonly PERCENTILE_CONT = 291;
    static readonly PERCENTILE_DISC = 292;
    static readonly PERCENT_RANK = 293;
    static readonly PERIOD = 294;
    static readonly PERMUTE = 295;
    static readonly PORTION = 296;
    static readonly POSITION = 297;
    static readonly POSITION_REGEX = 298;
    static readonly POWER = 299;
    static readonly PRECEDES = 300;
    static readonly PRECISION = 301;
    static readonly PREPARE = 302;
    static readonly PREV = 303;
    static readonly PRIMARY = 304;
    static readonly PROCEDURE = 305;
    static readonly RANGE = 306;
    static readonly RANK = 307;
    static readonly READS = 308;
    static readonly REAL = 309;
    static readonly RECURSIVE = 310;
    static readonly REF = 311;
    static readonly REFERENCES = 312;
    static readonly REFERENCING = 313;
    static readonly REFRESH = 314;
    static readonly REFRESH_MODE = 315;
    static readonly REGR_AVGX = 316;
    static readonly REGR_AVGY = 317;
    static readonly REGR_COUNT = 318;
    static readonly REGR_INTERCEPT = 319;
    static readonly REGR_R2 = 320;
    static readonly REGR_SLOPE = 321;
    static readonly REGR_SXX = 322;
    static readonly REGR_SXY = 323;
    static readonly REGR_SYY = 324;
    static readonly RESET = 325;
    static readonly RESULT = 326;
    static readonly RESUME = 327;
    static readonly RETURN = 328;
    static readonly RETURNS = 329;
    static readonly REVOKE = 330;
    static readonly RIGHT = 331;
    static readonly ROLLBACK = 332;
    static readonly ROLLUP = 333;
    static readonly ROW = 334;
    static readonly ROWS = 335;
    static readonly ROW_NUMBER = 336;
    static readonly RUNNING = 337;
    static readonly SAVEPOINT = 338;
    static readonly SCOPE = 339;
    static readonly SCROLL = 340;
    static readonly SEARCH = 341;
    static readonly SECOND = 342;
    static readonly SEEK = 343;
    static readonly SELECT = 344;
    static readonly SENSITIVE = 345;
    static readonly SESSION_USER = 346;
    static readonly SET = 347;
    static readonly SHOW = 348;
    static readonly SIMILAR = 349;
    static readonly SKIP_W = 350;
    static readonly SMALLINT = 351;
    static readonly SOME = 352;
    static readonly SPECIFIC = 353;
    static readonly SPECIFICTYPE = 354;
    static readonly SQL = 355;
    static readonly SQLEXCEPTION = 356;
    static readonly SQLSTATE = 357;
    static readonly SQLWARNING = 358;
    static readonly SQRT = 359;
    static readonly START = 360;
    static readonly STATIC = 361;
    static readonly STDDEV_POP = 362;
    static readonly STDDEV_SAMP = 363;
    static readonly STREAM = 364;
    static readonly SUBMULTISET = 365;
    static readonly SUBSET = 366;
    static readonly SUBSTRING = 367;
    static readonly SUBSTRING_REGEX = 368;
    static readonly SUCCEEDS = 369;
    static readonly SUM = 370;
    static readonly SUSPEND = 371;
    static readonly SYMMETRIC = 372;
    static readonly SYSTEM = 373;
    static readonly SYSTEM_TIME = 374;
    static readonly SYSTEM_USER = 375;
    static readonly TABLE = 376;
    static readonly TABLESAMPLE = 377;
    static readonly THEN = 378;
    static readonly TIME = 379;
    static readonly TIMESTAMP = 380;
    static readonly TIMEZONE_HOUR = 381;
    static readonly TIMEZONE_MINUTE = 382;
    static readonly TINYINT = 383;
    static readonly TO = 384;
    static readonly TRAILING = 385;
    static readonly TRANSLATE = 386;
    static readonly TRANSLATE_REGEX = 387;
    static readonly TRANSLATION = 388;
    static readonly TREAT = 389;
    static readonly TRIGGER = 390;
    static readonly TRIM = 391;
    static readonly TRIM_ARRRAY = 392;
    static readonly TRUE = 393;
    static readonly TRUNCATE = 394;
    static readonly UESCAPE = 395;
    static readonly UNION = 396;
    static readonly UNIQUE = 397;
    static readonly UNKNOWN = 398;
    static readonly UNNEST = 399;
    static readonly UPDATE = 400;
    static readonly UPPER = 401;
    static readonly UPSERT = 402;
    static readonly USER = 403;
    static readonly USING = 404;
    static readonly VALUE = 405;
    static readonly VALUES = 406;
    static readonly VALUE_OF = 407;
    static readonly VARBINARY = 408;
    static readonly VARCHAR = 409;
    static readonly VARYING = 410;
    static readonly VAR_POP = 411;
    static readonly VAR_SAMP = 412;
    static readonly VERSIONING = 413;
    static readonly WHEN = 414;
    static readonly WHENEVER = 415;
    static readonly WHERE = 416;
    static readonly WIDTH_BUCKET = 417;
    static readonly WINDOW = 418;
    static readonly WITH = 419;
    static readonly WITHIN = 420;
    static readonly WITHOUT = 421;
    static readonly YEAR = 422;
    static readonly ABSENT = 423;
    static readonly ACTION = 424;
    static readonly ADD = 425;
    static readonly AFTER = 426;
    static readonly APPLY = 427;
    static readonly ASC = 428;
    static readonly CASCADE = 429;
    static readonly CATALOG = 430;
    static readonly CENTURY = 431;
    static readonly CONDITIONAL = 432;
    static readonly CONSTRAINTS = 433;
    static readonly DATA = 434;
    static readonly DATABASE = 435;
    static readonly DAYS = 436;
    static readonly DECADE = 437;
    static readonly DESC = 438;
    static readonly DOW = 439;
    static readonly DOY = 440;
    static readonly EPOCH = 441;
    static readonly ERROR = 442;
    static readonly EXCLUDING = 443;
    static readonly FIRST = 444;
    static readonly FORMAT = 445;
    static readonly FRAC_SECOND = 446;
    static readonly GENERATED = 447;
    static readonly GEOMETRY = 448;
    static readonly GO = 449;
    static readonly HASH = 450;
    static readonly HOP = 451;
    static readonly HOURS = 452;
    static readonly IGNORE = 453;
    static readonly INCLUDING = 454;
    static readonly ISODOW = 455;
    static readonly ISOYEAR = 456;
    static readonly JAVA = 457;
    static readonly JSON = 458;
    static readonly KEY = 459;
    static readonly LAST = 460;
    static readonly MAP = 461;
    static readonly MICROSECOND = 462;
    static readonly MILLENNIUM = 463;
    static readonly MILLISECOND = 464;
    static readonly MINUTES = 465;
    static readonly MONTHS = 466;
    static readonly NANOSECOND = 467;
    static readonly NULLS = 468;
    static readonly OBJECT = 469;
    static readonly OPTIONS = 470;
    static readonly ORDINALITY = 471;
    static readonly PARTIAL = 472;
    static readonly PAST = 473;
    static readonly PIVOT = 474;
    static readonly PLACING = 475;
    static readonly PLAN = 476;
    static readonly PLI = 477;
    static readonly PRECEDING = 478;
    static readonly QUARTER = 479;
    static readonly REPLACE = 480;
    static readonly RESPECT = 481;
    static readonly RESTRICT = 482;
    static readonly RETURNING = 483;
    static readonly SCALAR = 484;
    static readonly SECONDS = 485;
    static readonly SESSION = 486;
    static readonly SETS = 487;
    static readonly SIZE = 488;
    static readonly SQL_TSI_DAY = 489;
    static readonly SQL_TSI_FRAC_SECOND = 490;
    static readonly SQL_TSI_HOUR = 491;
    static readonly SQL_TSI_MICROSECOND = 492;
    static readonly SQL_TSI_MINUTE = 493;
    static readonly SQL_TSI_MONTH = 494;
    static readonly SQL_TSI_QUARTER = 495;
    static readonly SQL_TSI_SECOND = 496;
    static readonly SQL_TSI_WEEK = 497;
    static readonly SQL_TSI_YEAR = 498;
    static readonly STATEMENT = 499;
    static readonly TEMPORARY = 500;
    static readonly TUMBLE = 501;
    static readonly UNCONDITIONAL = 502;
    static readonly UNPIVOT = 503;
    static readonly VIEW = 504;
    static readonly WEEK = 505;
    static readonly WRAPPER = 506;
    static readonly YEARS = 507;
    static readonly ZONE = 508;
    static readonly ANALYZE = 509;
    static readonly BYTES = 510;
    static readonly CATALOGS = 511;
    static readonly COMMENT = 512;
    static readonly COMPUTE = 513;
    static readonly COLUMNS = 514;
    static readonly CUMULATE = 515;
    static readonly CURVE = 516;
    static readonly DATABASES = 517;
    static readonly ENFORCED = 518;
    static readonly FUNCTIONS = 519;
    static readonly GEOMETRYCOLLECTION = 520;
    static readonly IF = 521;
    static readonly JAR = 522;
    static readonly LINESTRING = 523;
    static readonly LOAD = 524;
    static readonly METADATA = 525;
    static readonly MODULES = 526;
    static readonly MULTICURVE = 527;
    static readonly MULTILINESTRING = 528;
    static readonly MULTIPOINT = 529;
    static readonly MULTIPOLYGON = 530;
    static readonly MULTISURFACE = 531;
    static readonly OVERWRITE = 532;
    static readonly OVERWRITING = 533;
    static readonly PARTITIONED = 534;
    static readonly PARTITIONS = 535;
    static readonly PLAN_ADVICE = 536;
    static readonly POINT = 537;
    static readonly POLYHEDRALSURFACE = 538;
    static readonly POLYGON = 539;
    static readonly PYTHON = 540;
    static readonly RAW = 541;
    static readonly RENAME = 542;
    static readonly SCALA = 543;
    static readonly SLIDE = 544;
    static readonly STATISTICS = 545;
    static readonly STEP = 546;
    static readonly STRING = 547;
    static readonly SUBSTR = 548;
    static readonly SURFACE = 549;
    static readonly TABLES = 550;
    static readonly TIMECOL = 551;
    static readonly TIMESTAMP_LTZ = 552;
    static readonly TRY_CAST = 553;
    static readonly UNLOAD = 554;
    static readonly USE = 555;
    static readonly VIEWS = 556;
    static readonly VIRTUAL = 557;
    static readonly WATERMARK = 558;
    static readonly WATERMARKS = 559;
    static readonly REAL_LITERAL = 560;
    static readonly STRING_LITERAL = 561;
    static readonly IDENTIFIER = 562;
    static readonly BIND_PARAMETER = 563;
    static readonly RULE_program = 0;
    static readonly RULE_statements = 1;
    static readonly RULE_statement = 2;
    static readonly RULE_statementEnd = 3;
    static readonly RULE_end = 4;
    static readonly RULE_autoOptimize = 5;
    static readonly RULE_autoOptimizeTable = 6;
    static readonly RULE_autoOptimizeDatabase = 7;
    static readonly RULE_analyze = 8;
    static readonly RULE_query = 9;
    static readonly RULE_queryTerm = 10;
    static readonly RULE_queryPrimary = 11;
    static readonly RULE_ctes = 12;
    static readonly RULE_mapQuery = 13;
    static readonly RULE_queryOrderBy = 14;
    static readonly RULE_queryLimit = 15;
    static readonly RULE_queryOffset = 16;
    static readonly RULE_queryFetch = 17;
    static readonly RULE_withItem = 18;
    static readonly RULE_orderItem = 19;
    static readonly RULE_selectClause = 20;
    static readonly RULE_select = 21;
    static readonly RULE_projectItems = 22;
    static readonly RULE_fromTable = 23;
    static readonly RULE_where = 24;
    static readonly RULE_groupBy = 25;
    static readonly RULE_groupItems = 26;
    static readonly RULE_having = 27;
    static readonly RULE_windowSelect = 28;
    static readonly RULE_projectItem = 29;
    static readonly RULE_setQuantifier = 30;
    static readonly RULE_tableExpression = 31;
    static readonly RULE_tableExpr = 32;
    static readonly RULE_mapTable = 33;
    static readonly RULE_joinCondition = 34;
    static readonly RULE_commaTable = 35;
    static readonly RULE_tableReference = 36;
    static readonly RULE_tableDim = 37;
    static readonly RULE_tablePrimary = 38;
    static readonly RULE_tableSource = 39;
    static readonly RULE_tableLateral = 40;
    static readonly RULE_tableQuery = 41;
    static readonly RULE_hints = 42;
    static readonly RULE_hint = 43;
    static readonly RULE_hintOptions = 44;
    static readonly RULE_hintKVOption = 45;
    static readonly RULE_optionValue = 46;
    static readonly RULE_optionName = 47;
    static readonly RULE_pivot = 48;
    static readonly RULE_pivotAggs = 49;
    static readonly RULE_forPivotList = 50;
    static readonly RULE_pivotAgg = 51;
    static readonly RULE_pivotList = 52;
    static readonly RULE_columnOrList = 53;
    static readonly RULE_exprOrList = 54;
    static readonly RULE_inPivotExprs = 55;
    static readonly RULE_pivotExprs = 56;
    static readonly RULE_pivotExpr = 57;
    static readonly RULE_unpivot = 58;
    static readonly RULE_unpivotMeasureList = 59;
    static readonly RULE_unpivotAxisList = 60;
    static readonly RULE_unpivotValue = 61;
    static readonly RULE_values = 62;
    static readonly RULE_valuesRows = 63;
    static readonly RULE_valuesRowsParenthesis = 64;
    static readonly RULE_valueRow = 65;
    static readonly RULE_groupItem = 66;
    static readonly RULE_groupingSets = 67;
    static readonly RULE_parenthesisGroupItems = 68;
    static readonly RULE_window = 69;
    static readonly RULE_windowSpec = 70;
    static readonly RULE_rangeOrRows = 71;
    static readonly RULE_setStatement = 72;
    static readonly RULE_resetStatement = 73;
    static readonly RULE_alter = 74;
    static readonly RULE_alterTable = 75;
    static readonly RULE_alterView = 76;
    static readonly RULE_alterDatabase = 77;
    static readonly RULE_alterFunction = 78;
    static readonly RULE_alterMaterializedTable = 79;
    static readonly RULE_renameTo = 80;
    static readonly RULE_setValues = 81;
    static readonly RULE_explain = 82;
    static readonly RULE_explainDetails = 83;
    static readonly RULE_explainDetail = 84;
    static readonly RULE_describe = 85;
    static readonly RULE_describeCatalog = 86;
    static readonly RULE_describeDatabase = 87;
    static readonly RULE_describeTable = 88;
    static readonly RULE_insert = 89;
    static readonly RULE_partition = 90;
    static readonly RULE_insertMultiple = 91;
    static readonly RULE_executeStatementSet = 92;
    static readonly RULE_beginStatementSet = 93;
    static readonly RULE_use = 94;
    static readonly RULE_show = 95;
    static readonly RULE_ddlStatement = 96;
    static readonly RULE_create = 97;
    static readonly RULE_createTable = 98;
    static readonly RULE_createMaterializedTable = 99;
    static readonly RULE_defineValues = 100;
    static readonly RULE_partitionedBy = 101;
    static readonly RULE_distributedBy = 102;
    static readonly RULE_intoBuckets = 103;
    static readonly RULE_withValues = 104;
    static readonly RULE_likeTable = 105;
    static readonly RULE_asTable = 106;
    static readonly RULE_freshness = 107;
    static readonly RULE_refreshMode = 108;
    static readonly RULE_tableElement = 109;
    static readonly RULE_columnDefinition = 110;
    static readonly RULE_columnConstraint = 111;
    static readonly RULE_tableConstraint = 112;
    static readonly RULE_watermarkDefinition = 113;
    static readonly RULE_likeConfig = 114;
    static readonly RULE_likeOptions = 115;
    static readonly RULE_likeOption = 116;
    static readonly RULE_createCatalog = 117;
    static readonly RULE_createDatabase = 118;
    static readonly RULE_asDatabase = 119;
    static readonly RULE_includingTable = 120;
    static readonly RULE_excludingTable = 121;
    static readonly RULE_createView = 122;
    static readonly RULE_createFunction = 123;
    static readonly RULE_drop = 124;
    static readonly RULE_dropTable = 125;
    static readonly RULE_dropDatabase = 126;
    static readonly RULE_dropView = 127;
    static readonly RULE_dropFunction = 128;
    static readonly RULE_dropMaterializedTable = 129;
    static readonly RULE_addJar = 130;
    static readonly RULE_moduleStatement = 131;
    static readonly RULE_loadModule = 132;
    static readonly RULE_unloadModule = 133;
    static readonly RULE_useModules = 134;
    static readonly RULE_showModules = 135;
    static readonly RULE_type = 136;
    static readonly RULE_typeName = 137;
    static readonly RULE_sqlTypeName = 138;
    static readonly RULE_collectionsTypeName = 139;
    static readonly RULE_char = 140;
    static readonly RULE_varchar = 141;
    static readonly RULE_decimal = 142;
    static readonly RULE_varbinary = 143;
    static readonly RULE_rowType = 144;
    static readonly RULE_systemFunction = 145;
    static readonly RULE_jsonFunction = 146;
    static readonly RULE_jsonExistsFunction = 147;
    static readonly RULE_jsonValueFunction = 148;
    static readonly RULE_jsonQueryFunction = 149;
    static readonly RULE_jsonValue = 150;
    static readonly RULE_path = 151;
    static readonly RULE_jsonObjectFunction = 152;
    static readonly RULE_jsonObjectAggFunction = 153;
    static readonly RULE_jsonArrayFunction = 154;
    static readonly RULE_jsonArrayAggFunction = 155;
    static readonly RULE_jsonKeyVal = 156;
    static readonly RULE_jsonVal = 157;
    static readonly RULE_nullBehavior = 158;
    static readonly RULE_temporalFunction = 159;
    static readonly RULE_temporalOverlaps = 160;
    static readonly RULE_temporalDate = 161;
    static readonly RULE_temporalTime = 162;
    static readonly RULE_temporalTimestamp = 163;
    static readonly RULE_yearMonthInterval = 164;
    static readonly RULE_dayTimeInterval = 165;
    static readonly RULE_yearUnit = 166;
    static readonly RULE_monthUnit = 167;
    static readonly RULE_dayUnit = 168;
    static readonly RULE_hourUnit = 169;
    static readonly RULE_minuteUnit = 170;
    static readonly RULE_secondUnit = 171;
    static readonly RULE_timeIntervalUnit = 172;
    static readonly RULE_timePointUnit = 173;
    static readonly RULE_aggregateWithin = 174;
    static readonly RULE_aggregateFilter = 175;
    static readonly RULE_aggregateNulls = 176;
    static readonly RULE_overWindow = 177;
    static readonly RULE_expressions = 178;
    static readonly RULE_parenthesisExpressions = 179;
    static readonly RULE_parenthesisQuery = 180;
    static readonly RULE_columnAssignments = 181;
    static readonly RULE_columnAssignment = 182;
    static readonly RULE_valueAssignments = 183;
    static readonly RULE_valueAssignment = 184;
    static readonly RULE_columns = 185;
    static readonly RULE_columnsWithoutParenthesis = 186;
    static readonly RULE_comment = 187;
    static readonly RULE_orderBy = 188;
    static readonly RULE_orderItems = 189;
    static readonly RULE_partitionBy = 190;
    static readonly RULE_matchRecognize = 191;
    static readonly RULE_measures = 192;
    static readonly RULE_measureColumns = 193;
    static readonly RULE_perMatch = 194;
    static readonly RULE_afterMatch = 195;
    static readonly RULE_patternMatch = 196;
    static readonly RULE_withinMatch = 197;
    static readonly RULE_subsetMatch = 198;
    static readonly RULE_subsetItems = 199;
    static readonly RULE_subsetItem = 200;
    static readonly RULE_defineMatch = 201;
    static readonly RULE_defineItems = 202;
    static readonly RULE_defineItem = 203;
    static readonly RULE_measureColumn = 204;
    static readonly RULE_pattern = 205;
    static readonly RULE_patternTerm = 206;
    static readonly RULE_patternFactor = 207;
    static readonly RULE_patternPrimary = 208;
    static readonly RULE_patternQuantifier = 209;
    static readonly RULE_alias = 210;
    static readonly RULE_aliases = 211;
    static readonly RULE_keyword = 212;
    static readonly RULE_anyName = 213;
    static readonly RULE_anyNonStringName = 214;
    static readonly RULE_arrowWindowFunction = 215;
    static readonly RULE_charsetIntroducer = 216;
    static readonly RULE_charsetLiteral = 217;
    static readonly RULE_literalValue = 218;
    static readonly RULE_whenExpr = 219;
    static readonly RULE_thenExpr = 220;
    static readonly RULE_elseExpr = 221;
    static readonly RULE_caseEnd = 222;
    static readonly RULE_arrayConstruct = 223;
    static readonly RULE_compare = 224;
    static readonly RULE_logicalBind = 225;
    static readonly RULE_predicate = 226;
    static readonly RULE_expr = 227;
    static readonly RULE_booleanExpr = 228;
    static readonly RULE_valueExpr = 229;
    static readonly RULE_subQuery = 230;
    static readonly RULE_functionCall = 231;
    static readonly RULE_primaryExpr = 232;
    static readonly RULE_string = 233;
    static readonly RULE_name = 234;
    static readonly RULE_columnName = 235;
    static readonly RULE_tableName = 236;
    static readonly RULE_databaseName = 237;
    static readonly RULE_catalogName = 238;
    static readonly RULE_viewName = 239;
    static readonly RULE_functionName = 240;
    static readonly RULE_column = 241;
    static readonly RULE_view = 242;
    static readonly RULE_table = 243;
    static readonly RULE_database = 244;
    static readonly RULE_catalog = 245;
    static readonly RULE_reservedKeywords = 246;
    static readonly RULE_nonReservedKeywords = 247;
    static readonly RULE_commonKeywords = 248;
    static readonly ruleNames: string[];
    private static readonly _LITERAL_NAMES;
    private static readonly _SYMBOLIC_NAMES;
    static readonly VOCABULARY: Vocabulary;
    get vocabulary(): Vocabulary;
    get grammarFileName(): string;
    get ruleNames(): string[];
    get serializedATN(): string;
    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
    constructor(input: TokenStream);
    program(): ProgramContext;
    statements(): StatementsContext;
    statement(): StatementContext;
    statementEnd(): StatementEndContext;
    end(): EndContext;
    autoOptimize(): AutoOptimizeContext;
    autoOptimizeTable(): AutoOptimizeTableContext;
    autoOptimizeDatabase(): AutoOptimizeDatabaseContext;
    analyze(): AnalyzeContext;
    query(): QueryContext;
    queryTerm(): QueryTermContext;
    queryPrimary(): QueryPrimaryContext;
    ctes(): CtesContext;
    mapQuery(): MapQueryContext;
    queryOrderBy(): QueryOrderByContext;
    queryLimit(): QueryLimitContext;
    queryOffset(): QueryOffsetContext;
    queryFetch(): QueryFetchContext;
    withItem(): WithItemContext;
    orderItem(): OrderItemContext;
    selectClause(): SelectClauseContext;
    select(): SelectContext;
    projectItems(): ProjectItemsContext;
    fromTable(): FromTableContext;
    where(): WhereContext;
    groupBy(): GroupByContext;
    groupItems(): GroupItemsContext;
    having(): HavingContext;
    windowSelect(): WindowSelectContext;
    projectItem(): ProjectItemContext;
    setQuantifier(): SetQuantifierContext;
    tableExpression(): TableExpressionContext;
    tableExpr(): TableExprContext;
    mapTable(): MapTableContext;
    joinCondition(): JoinConditionContext;
    commaTable(): CommaTableContext;
    tableReference(): TableReferenceContext;
    tableDim(): TableDimContext;
    tablePrimary(): TablePrimaryContext;
    tableSource(): TableSourceContext;
    tableLateral(): TableLateralContext;
    tableQuery(): TableQueryContext;
    hints(): HintsContext;
    hint(): HintContext;
    hintOptions(): HintOptionsContext;
    hintKVOption(): HintKVOptionContext;
    optionValue(): OptionValueContext;
    optionName(): OptionNameContext;
    pivot(): PivotContext;
    pivotAggs(): PivotAggsContext;
    forPivotList(): ForPivotListContext;
    pivotAgg(): PivotAggContext;
    pivotList(): PivotListContext;
    columnOrList(): ColumnOrListContext;
    exprOrList(): ExprOrListContext;
    inPivotExprs(): InPivotExprsContext;
    pivotExprs(): PivotExprsContext;
    pivotExpr(): PivotExprContext;
    unpivot(): UnpivotContext;
    unpivotMeasureList(): UnpivotMeasureListContext;
    unpivotAxisList(): UnpivotAxisListContext;
    unpivotValue(): UnpivotValueContext;
    values(): ValuesContext;
    valuesRows(): ValuesRowsContext;
    valuesRowsParenthesis(): ValuesRowsParenthesisContext;
    valueRow(): ValueRowContext;
    groupItem(): GroupItemContext;
    groupingSets(): GroupingSetsContext;
    parenthesisGroupItems(): ParenthesisGroupItemsContext;
    window(): WindowContext;
    windowSpec(): WindowSpecContext;
    rangeOrRows(): RangeOrRowsContext;
    setStatement(): SetStatementContext;
    resetStatement(): ResetStatementContext;
    alter(): AlterContext;
    alterTable(): AlterTableContext;
    alterView(): AlterViewContext;
    alterDatabase(): AlterDatabaseContext;
    alterFunction(): AlterFunctionContext;
    alterMaterializedTable(): AlterMaterializedTableContext;
    renameTo(): RenameToContext;
    setValues(): SetValuesContext;
    explain(): ExplainContext;
    explainDetails(): ExplainDetailsContext;
    explainDetail(): ExplainDetailContext;
    describe(): DescribeContext;
    describeCatalog(): DescribeCatalogContext;
    describeDatabase(): DescribeDatabaseContext;
    describeTable(): DescribeTableContext;
    insert(): InsertContext;
    partition(): PartitionContext;
    insertMultiple(): InsertMultipleContext;
    executeStatementSet(): ExecuteStatementSetContext;
    beginStatementSet(): BeginStatementSetContext;
    use(): UseContext;
    show(): ShowContext;
    ddlStatement(): DdlStatementContext;
    create(): CreateContext;
    createTable(): CreateTableContext;
    createMaterializedTable(): CreateMaterializedTableContext;
    defineValues(): DefineValuesContext;
    partitionedBy(): PartitionedByContext;
    distributedBy(): DistributedByContext;
    intoBuckets(): IntoBucketsContext;
    withValues(): WithValuesContext;
    likeTable(): LikeTableContext;
    asTable(): AsTableContext;
    freshness(): FreshnessContext;
    refreshMode(): RefreshModeContext;
    tableElement(): TableElementContext;
    columnDefinition(): ColumnDefinitionContext;
    columnConstraint(): ColumnConstraintContext;
    tableConstraint(): TableConstraintContext;
    watermarkDefinition(): WatermarkDefinitionContext;
    likeConfig(): LikeConfigContext;
    likeOptions(): LikeOptionsContext;
    likeOption(): LikeOptionContext;
    createCatalog(): CreateCatalogContext;
    createDatabase(): CreateDatabaseContext;
    asDatabase(): AsDatabaseContext;
    includingTable(): IncludingTableContext;
    excludingTable(): ExcludingTableContext;
    createView(): CreateViewContext;
    createFunction(): CreateFunctionContext;
    drop(): DropContext;
    dropTable(): DropTableContext;
    dropDatabase(): DropDatabaseContext;
    dropView(): DropViewContext;
    dropFunction(): DropFunctionContext;
    dropMaterializedTable(): DropMaterializedTableContext;
    addJar(): AddJarContext;
    moduleStatement(): ModuleStatementContext;
    loadModule(): LoadModuleContext;
    unloadModule(): UnloadModuleContext;
    useModules(): UseModulesContext;
    showModules(): ShowModulesContext;
    type(): TypeContext;
    typeName(): TypeNameContext;
    sqlTypeName(): SqlTypeNameContext;
    collectionsTypeName(): CollectionsTypeNameContext;
    char(): CharContext;
    varchar(): VarcharContext;
    decimal(): DecimalContext;
    varbinary(): VarbinaryContext;
    rowType(): RowTypeContext;
    systemFunction(): SystemFunctionContext;
    jsonFunction(): JsonFunctionContext;
    jsonExistsFunction(): JsonExistsFunctionContext;
    jsonValueFunction(): JsonValueFunctionContext;
    jsonQueryFunction(): JsonQueryFunctionContext;
    jsonValue(): JsonValueContext;
    path(): PathContext;
    jsonObjectFunction(): JsonObjectFunctionContext;
    jsonObjectAggFunction(): JsonObjectAggFunctionContext;
    jsonArrayFunction(): JsonArrayFunctionContext;
    jsonArrayAggFunction(): JsonArrayAggFunctionContext;
    jsonKeyVal(): JsonKeyValContext;
    jsonVal(): JsonValContext;
    nullBehavior(): NullBehaviorContext;
    temporalFunction(): TemporalFunctionContext;
    temporalOverlaps(): TemporalOverlapsContext;
    temporalDate(): TemporalDateContext;
    temporalTime(): TemporalTimeContext;
    temporalTimestamp(): TemporalTimestampContext;
    yearMonthInterval(): YearMonthIntervalContext;
    dayTimeInterval(): DayTimeIntervalContext;
    yearUnit(): YearUnitContext;
    monthUnit(): MonthUnitContext;
    dayUnit(): DayUnitContext;
    hourUnit(): HourUnitContext;
    minuteUnit(): MinuteUnitContext;
    secondUnit(): SecondUnitContext;
    timeIntervalUnit(): TimeIntervalUnitContext;
    timePointUnit(): TimePointUnitContext;
    aggregateWithin(): AggregateWithinContext;
    aggregateFilter(): AggregateFilterContext;
    aggregateNulls(): AggregateNullsContext;
    overWindow(): OverWindowContext;
    expressions(): ExpressionsContext;
    parenthesisExpressions(): ParenthesisExpressionsContext;
    parenthesisQuery(): ParenthesisQueryContext;
    columnAssignments(): ColumnAssignmentsContext;
    columnAssignment(): ColumnAssignmentContext;
    valueAssignments(): ValueAssignmentsContext;
    valueAssignment(): ValueAssignmentContext;
    columns(): ColumnsContext;
    columnsWithoutParenthesis(): ColumnsWithoutParenthesisContext;
    comment(): CommentContext;
    orderBy(): OrderByContext;
    orderItems(): OrderItemsContext;
    partitionBy(): PartitionByContext;
    matchRecognize(): MatchRecognizeContext;
    measures(): MeasuresContext;
    measureColumns(): MeasureColumnsContext;
    perMatch(): PerMatchContext;
    afterMatch(): AfterMatchContext;
    patternMatch(): PatternMatchContext;
    withinMatch(): WithinMatchContext;
    subsetMatch(): SubsetMatchContext;
    subsetItems(): SubsetItemsContext;
    subsetItem(): SubsetItemContext;
    defineMatch(): DefineMatchContext;
    defineItems(): DefineItemsContext;
    defineItem(): DefineItemContext;
    measureColumn(): MeasureColumnContext;
    pattern(): PatternContext;
    patternTerm(): PatternTermContext;
    patternFactor(): PatternFactorContext;
    patternPrimary(): PatternPrimaryContext;
    patternQuantifier(): PatternQuantifierContext;
    alias(): AliasContext;
    aliases(): AliasesContext;
    keyword(): KeywordContext;
    anyName(): AnyNameContext;
    anyNonStringName(): AnyNonStringNameContext;
    arrowWindowFunction(): ArrowWindowFunctionContext;
    charsetIntroducer(): CharsetIntroducerContext;
    charsetLiteral(): CharsetLiteralContext;
    literalValue(): LiteralValueContext;
    whenExpr(): WhenExprContext;
    thenExpr(): ThenExprContext;
    elseExpr(): ElseExprContext;
    caseEnd(): CaseEndContext;
    arrayConstruct(): ArrayConstructContext;
    compare(): CompareContext;
    logicalBind(): LogicalBindContext;
    predicate(): PredicateContext;
    expr(): ExprContext;
    booleanExpr(): BooleanExprContext;
    booleanExpr(_p: number): BooleanExprContext;
    valueExpr(): ValueExprContext;
    valueExpr(_p: number): ValueExprContext;
    subQuery(): SubQueryContext;
    functionCall(): FunctionCallContext;
    primaryExpr(): PrimaryExprContext;
    primaryExpr(_p: number): PrimaryExprContext;
    string(): StringContext;
    name(): NameContext;
    columnName(): ColumnNameContext;
    tableName(): TableNameContext;
    databaseName(): DatabaseNameContext;
    catalogName(): CatalogNameContext;
    viewName(): ViewNameContext;
    functionName(): FunctionNameContext;
    column(): ColumnContext;
    view(): ViewContext;
    table(): TableContext;
    database(): DatabaseContext;
    catalog(): CatalogContext;
    reservedKeywords(): ReservedKeywordsContext;
    nonReservedKeywords(): NonReservedKeywordsContext;
    commonKeywords(): CommonKeywordsContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private booleanExpr_sempred;
    private valueExpr_sempred;
    private primaryExpr_sempred;
    private static readonly _serializedATNSegments;
    private static readonly _serializedATNSegment0;
    private static readonly _serializedATNSegment1;
    private static readonly _serializedATNSegment2;
    private static readonly _serializedATNSegment3;
    private static readonly _serializedATNSegment4;
    private static readonly _serializedATNSegment5;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class ProgramContext extends ParserRuleContext {
    statements(): StatementsContext | undefined;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class StatementsContext extends ParserRuleContext {
    statement(): StatementContext[];
    statement(i: number): StatementContext;
    statementEnd(): StatementEndContext[];
    statementEnd(i: number): StatementEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class StatementContext extends ParserRuleContext {
    ddlStatement(): DdlStatementContext | undefined;
    insert(): InsertContext | undefined;
    insertMultiple(): InsertMultipleContext | undefined;
    query(): QueryContext | undefined;
    alter(): AlterContext | undefined;
    explain(): ExplainContext | undefined;
    autoOptimize(): AutoOptimizeContext | undefined;
    setStatement(): SetStatementContext | undefined;
    resetStatement(): ResetStatementContext | undefined;
    analyze(): AnalyzeContext | undefined;
    describe(): DescribeContext | undefined;
    use(): UseContext | undefined;
    show(): ShowContext | undefined;
    addJar(): AddJarContext | undefined;
    moduleStatement(): ModuleStatementContext | undefined;
    end(): EndContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class StatementEndContext extends ParserRuleContext {
    SEMICOLON(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class EndContext extends ParserRuleContext {
    END(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AutoOptimizeContext extends ParserRuleContext {
    autoOptimizeTable(): AutoOptimizeTableContext | undefined;
    autoOptimizeDatabase(): AutoOptimizeDatabaseContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AutoOptimizeTableContext extends ParserRuleContext {
    AUTO(): TerminalNode;
    OPTIMIZE(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AutoOptimizeDatabaseContext extends ParserRuleContext {
    AUTO(): TerminalNode;
    OPTIMIZE(): TerminalNode;
    DATABASE(): TerminalNode;
    database(): DatabaseContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AnalyzeContext extends ParserRuleContext {
    ANALYZE(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    COMPUTE(): TerminalNode;
    STATISTICS(): TerminalNode;
    FOR(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    columnsWithoutParenthesis(): ColumnsWithoutParenthesisContext | undefined;
    ALL(): TerminalNode | undefined;
    partition(): PartitionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class QueryContext extends ParserRuleContext {
    queryTerm(): QueryTermContext;
    ctes(): CtesContext | undefined;
    queryOrderBy(): QueryOrderByContext | undefined;
    queryLimit(): QueryLimitContext | undefined;
    queryOffset(): QueryOffsetContext | undefined;
    queryFetch(): QueryFetchContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class QueryTermContext extends ParserRuleContext {
    queryPrimary(): QueryPrimaryContext;
    mapQuery(): MapQueryContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class QueryPrimaryContext extends ParserRuleContext {
    select(): SelectContext | undefined;
    TABLE(): TerminalNode | undefined;
    table(): TableContext | undefined;
    values(): ValuesContext | undefined;
    parenthesisQuery(): ParenthesisQueryContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CtesContext extends ParserRuleContext {
    WITH(): TerminalNode;
    withItem(): WithItemContext[];
    withItem(i: number): WithItemContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MapQueryContext extends ParserRuleContext {
    queryTerm(): QueryTermContext;
    UNION(): TerminalNode | undefined;
    EXCEPT(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    INTERSECT(): TerminalNode | undefined;
    setQuantifier(): SetQuantifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class QueryOrderByContext extends ParserRuleContext {
    ORDER(): TerminalNode;
    BY(): TerminalNode;
    orderItems(): OrderItemsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class QueryLimitContext extends ParserRuleContext {
    LIMIT(): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    ALL(): TerminalNode | undefined;
    COMMA(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class QueryOffsetContext extends ParserRuleContext {
    OFFSET(): TerminalNode;
    expr(): ExprContext;
    ROW(): TerminalNode | undefined;
    ROWS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class QueryFetchContext extends ParserRuleContext {
    FETCH(): TerminalNode;
    ONLY(): TerminalNode;
    FIRST(): TerminalNode | undefined;
    NEXT(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    ROWS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WithItemContext extends ParserRuleContext {
    tableName(): TableNameContext;
    parenthesisQuery(): ParenthesisQueryContext;
    columns(): ColumnsContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class OrderItemContext extends ParserRuleContext {
    expr(): ExprContext;
    NULLS(): TerminalNode | undefined;
    FIRST(): TerminalNode | undefined;
    LAST(): TerminalNode | undefined;
    ASC(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SelectClauseContext extends ParserRuleContext {
    SELECT(): TerminalNode;
    projectItems(): ProjectItemsContext;
    hints(): HintsContext | undefined;
    STREAM(): TerminalNode | undefined;
    setQuantifier(): SetQuantifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SelectContext extends ParserRuleContext {
    selectClause(): SelectClauseContext;
    fromTable(): FromTableContext | undefined;
    where(): WhereContext | undefined;
    groupBy(): GroupByContext | undefined;
    having(): HavingContext | undefined;
    windowSelect(): WindowSelectContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ProjectItemsContext extends ParserRuleContext {
    projectItem(): ProjectItemContext[];
    projectItem(i: number): ProjectItemContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class FromTableContext extends ParserRuleContext {
    FROM(): TerminalNode;
    tableExpression(): TableExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WhereContext extends ParserRuleContext {
    WHERE(): TerminalNode;
    booleanExpr(): BooleanExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class GroupByContext extends ParserRuleContext {
    GROUP(): TerminalNode;
    BY(): TerminalNode;
    groupItems(): GroupItemsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class GroupItemsContext extends ParserRuleContext {
    groupItem(): GroupItemContext[];
    groupItem(i: number): GroupItemContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class HavingContext extends ParserRuleContext {
    HAVING(): TerminalNode;
    booleanExpr(): BooleanExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WindowSelectContext extends ParserRuleContext {
    _windowName: ExprContext;
    WINDOW(): TerminalNode;
    AS(): TerminalNode[];
    AS(i: number): TerminalNode;
    windowSpec(): WindowSpecContext[];
    windowSpec(i: number): WindowSpecContext;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ProjectItemContext extends ParserRuleContext {
    _columnAlias: AliasContext;
    expr(): ExprContext;
    alias(): AliasContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SetQuantifierContext extends ParserRuleContext {
    ALL(): TerminalNode | undefined;
    DISTINCT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableExpressionContext extends ParserRuleContext {
    tableExpr(): TableExprContext;
    commaTable(): CommaTableContext[];
    commaTable(i: number): CommaTableContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableExprContext extends ParserRuleContext {
    tableReference(): TableReferenceContext;
    mapTable(): MapTableContext[];
    mapTable(i: number): MapTableContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MapTableContext extends ParserRuleContext {
    CROSS(): TerminalNode | undefined;
    JOIN(): TerminalNode | undefined;
    tableReference(): TableReferenceContext;
    NATURAL(): TerminalNode | undefined;
    INNER(): TerminalNode | undefined;
    joinCondition(): JoinConditionContext | undefined;
    LEFT(): TerminalNode | undefined;
    RIGHT(): TerminalNode | undefined;
    FULL(): TerminalNode | undefined;
    OUTER(): TerminalNode | undefined;
    APPLY(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JoinConditionContext extends ParserRuleContext {
    ON(): TerminalNode | undefined;
    booleanExpr(): BooleanExprContext | undefined;
    USING(): TerminalNode | undefined;
    columns(): ColumnsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CommaTableContext extends ParserRuleContext {
    COMMA(): TerminalNode;
    tableExpr(): TableExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableReferenceContext extends ParserRuleContext {
    tablePrimary(): TablePrimaryContext;
    matchRecognize(): MatchRecognizeContext | undefined;
    pivot(): PivotContext | undefined;
    unpivot(): UnpivotContext | undefined;
    alias(): AliasContext | undefined;
    AS(): TerminalNode | undefined;
    aliases(): AliasesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableDimContext extends ParserRuleContext {
    FOR(): TerminalNode;
    SYSTEM_TIME(): TerminalNode;
    AS(): TerminalNode;
    OF(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TablePrimaryContext extends ParserRuleContext {
    tableSource(): TableSourceContext | undefined;
    tableLateral(): TableLateralContext | undefined;
    tableQuery(): TableQueryContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableSourceContext extends ParserRuleContext {
    table(): TableContext | undefined;
    hints(): HintsContext | undefined;
    tableDim(): TableDimContext | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    UNNEST(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    WITH(): TerminalNode | undefined;
    ORDINALITY(): TerminalNode | undefined;
    valuesRows(): ValuesRowsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableLateralContext extends ParserRuleContext {
    TABLE(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    expr(): ExprContext;
    R_PARENTHESIS(): TerminalNode;
    LATERAL(): TerminalNode | undefined;
    SPECIFIC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableQueryContext extends ParserRuleContext {
    parenthesisQuery(): ParenthesisQueryContext;
    LATERAL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class HintsContext extends ParserRuleContext {
    L_HINT(): TerminalNode;
    hint(): HintContext[];
    hint(i: number): HintContext;
    R_HINT(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class HintContext extends ParserRuleContext {
    _hintName: NameContext;
    name(): NameContext;
    L_PARENTHESIS(): TerminalNode | undefined;
    hintOptions(): HintOptionsContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class HintOptionsContext extends ParserRuleContext {
    hintKVOption(): HintKVOptionContext[];
    hintKVOption(i: number): HintKVOptionContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    optionName(): OptionNameContext[];
    optionName(i: number): OptionNameContext;
    optionValue(): OptionValueContext[];
    optionValue(i: number): OptionValueContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class HintKVOptionContext extends ParserRuleContext {
    optionName(): OptionNameContext;
    EQUAL(): TerminalNode;
    name(): NameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class OptionValueContext extends ParserRuleContext {
    name(): NameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class OptionNameContext extends ParserRuleContext {
    name(): NameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PivotContext extends ParserRuleContext {
    PIVOT(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    pivotAggs(): PivotAggsContext;
    forPivotList(): ForPivotListContext;
    inPivotExprs(): InPivotExprsContext;
    R_PARENTHESIS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PivotAggsContext extends ParserRuleContext {
    pivotAgg(): PivotAggContext[];
    pivotAgg(i: number): PivotAggContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ForPivotListContext extends ParserRuleContext {
    FOR(): TerminalNode;
    pivotList(): PivotListContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PivotAggContext extends ParserRuleContext {
    expr(): ExprContext;
    alias(): AliasContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PivotListContext extends ParserRuleContext {
    columnOrList(): ColumnOrListContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnOrListContext extends ParserRuleContext {
    columnName(): ColumnNameContext | undefined;
    columns(): ColumnsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExprOrListContext extends ParserRuleContext {
    expr(): ExprContext | undefined;
    parenthesisExpressions(): ParenthesisExpressionsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class InPivotExprsContext extends ParserRuleContext {
    IN(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    pivotExprs(): PivotExprsContext;
    R_PARENTHESIS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PivotExprsContext extends ParserRuleContext {
    pivotExpr(): PivotExprContext[];
    pivotExpr(i: number): PivotExprContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PivotExprContext extends ParserRuleContext {
    exprOrList(): ExprOrListContext;
    alias(): AliasContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class UnpivotContext extends ParserRuleContext {
    UNPIVOT(): TerminalNode;
    L_PARENTHESIS(): TerminalNode[];
    L_PARENTHESIS(i: number): TerminalNode;
    unpivotMeasureList(): UnpivotMeasureListContext;
    FOR(): TerminalNode;
    unpivotAxisList(): UnpivotAxisListContext;
    IN(): TerminalNode;
    unpivotValue(): UnpivotValueContext[];
    unpivotValue(i: number): UnpivotValueContext;
    R_PARENTHESIS(): TerminalNode[];
    R_PARENTHESIS(i: number): TerminalNode;
    INCLUDING(): TerminalNode | undefined;
    NULLS(): TerminalNode | undefined;
    EXCLUDING(): TerminalNode | undefined;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class UnpivotMeasureListContext extends ParserRuleContext {
    columnOrList(): ColumnOrListContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class UnpivotAxisListContext extends ParserRuleContext {
    columnOrList(): ColumnOrListContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class UnpivotValueContext extends ParserRuleContext {
    columnName(): ColumnNameContext | undefined;
    AS(): TerminalNode | undefined;
    alias(): AliasContext | undefined;
    columns(): ColumnsContext | undefined;
    aliases(): AliasesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ValuesContext extends ParserRuleContext {
    valuesRows(): ValuesRowsContext | undefined;
    valuesRowsParenthesis(): ValuesRowsParenthesisContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ValuesRowsContext extends ParserRuleContext {
    VALUES(): TerminalNode;
    valueRow(): ValueRowContext[];
    valueRow(i: number): ValueRowContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ValuesRowsParenthesisContext extends ParserRuleContext {
    VALUES(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    valueRow(): ValueRowContext[];
    valueRow(i: number): ValueRowContext;
    R_PARENTHESIS(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ValueRowContext extends ParserRuleContext {
    parenthesisExpressions(): ParenthesisExpressionsContext | undefined;
    expressions(): ExpressionsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class GroupItemContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    parenthesisExpressions(): ParenthesisExpressionsContext | undefined;
    CUBE(): TerminalNode | undefined;
    ROLLUP(): TerminalNode | undefined;
    groupingSets(): GroupingSetsContext | undefined;
    expr(): ExprContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class GroupingSetsContext extends ParserRuleContext {
    GROUPING(): TerminalNode;
    SETS(): TerminalNode;
    parenthesisGroupItems(): ParenthesisGroupItemsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ParenthesisGroupItemsContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    groupItems(): GroupItemsContext;
    R_PARENTHESIS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WindowContext extends ParserRuleContext {
    _windowName: NameContext;
    windowSpec(): WindowSpecContext | undefined;
    name(): NameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WindowSpecContext extends ParserRuleContext {
    _windowName: NameContext;
    L_PARENTHESIS(): TerminalNode;
    R_PARENTHESIS(): TerminalNode;
    alias(): AliasContext | undefined;
    partitionBy(): PartitionByContext | undefined;
    orderBy(): OrderByContext | undefined;
    rangeOrRows(): RangeOrRowsContext | undefined;
    name(): NameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class RangeOrRowsContext extends ParserRuleContext {
    RANGE(): TerminalNode | undefined;
    ROWS(): TerminalNode | undefined;
    BETWEEN(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    PRECEDING(): TerminalNode | undefined;
    AND(): TerminalNode | undefined;
    CURRENT(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    PARTIAL(): TerminalNode | undefined;
    ALLOW(): TerminalNode | undefined;
    DISALLOW(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SetStatementContext extends ParserRuleContext {
    SET(): TerminalNode;
    ALTER(): TerminalNode | undefined;
    valueAssignment(): ValueAssignmentContext | undefined;
    SYSTEM(): TerminalNode | undefined;
    SESSION(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ResetStatementContext extends ParserRuleContext {
    RESET(): TerminalNode;
    ALTER(): TerminalNode | undefined;
    name(): NameContext | undefined;
    ALL(): TerminalNode | undefined;
    SYSTEM(): TerminalNode | undefined;
    SESSION(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AlterContext extends ParserRuleContext {
    alterDatabase(): AlterDatabaseContext | undefined;
    alterFunction(): AlterFunctionContext | undefined;
    alterTable(): AlterTableContext | undefined;
    alterView(): AlterViewContext | undefined;
    alterMaterializedTable(): AlterMaterializedTableContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AlterTableContext extends ParserRuleContext {
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    renameTo(): RenameToContext | undefined;
    setValues(): SetValuesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AlterViewContext extends ParserRuleContext {
    ALTER(): TerminalNode;
    VIEW(): TerminalNode;
    view(): ViewContext;
    renameTo(): RenameToContext | undefined;
    setValues(): SetValuesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AlterDatabaseContext extends ParserRuleContext {
    ALTER(): TerminalNode;
    DATABASE(): TerminalNode;
    database(): DatabaseContext;
    setValues(): SetValuesContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AlterFunctionContext extends ParserRuleContext {
    ALTER(): TerminalNode;
    FUNCTION(): TerminalNode;
    functionName(): FunctionNameContext;
    AS(): TerminalNode;
    alias(): AliasContext;
    TEMPORARY(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    LANGUAGE(): TerminalNode | undefined;
    JAVA(): TerminalNode | undefined;
    SCALA(): TerminalNode | undefined;
    PYTHON(): TerminalNode | undefined;
    SYSTEM(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AlterMaterializedTableContext extends ParserRuleContext {
    ALTER(): TerminalNode;
    MATERIALIZED(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    SUSPEND(): TerminalNode | undefined;
    RESUME(): TerminalNode | undefined;
    REFRESH(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    query(): QueryContext | undefined;
    withValues(): WithValuesContext | undefined;
    partition(): PartitionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class RenameToContext extends ParserRuleContext {
    RENAME(): TerminalNode;
    TO(): TerminalNode;
    alias(): AliasContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SetValuesContext extends ParserRuleContext {
    SET(): TerminalNode;
    valueAssignments(): ValueAssignmentsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExplainContext extends ParserRuleContext {
    EXPLAIN(): TerminalNode;
    query(): QueryContext | undefined;
    insert(): InsertContext | undefined;
    PLAN(): TerminalNode | undefined;
    FOR(): TerminalNode | undefined;
    explainDetails(): ExplainDetailsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExplainDetailsContext extends ParserRuleContext {
    explainDetail(): ExplainDetailContext[];
    explainDetail(i: number): ExplainDetailContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExplainDetailContext extends ParserRuleContext {
    ESTIMATED_COST(): TerminalNode | undefined;
    CHANGELOG_MODE(): TerminalNode | undefined;
    JSON_EXECUTION_PLAN(): TerminalNode | undefined;
    PLAN_ADVICE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DescribeContext extends ParserRuleContext {
    describeCatalog(): DescribeCatalogContext | undefined;
    describeDatabase(): DescribeDatabaseContext | undefined;
    describeTable(): DescribeTableContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DescribeCatalogContext extends ParserRuleContext {
    CATALOG(): TerminalNode;
    catalog(): CatalogContext;
    DESCRIBE(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DescribeDatabaseContext extends ParserRuleContext {
    DATABASE(): TerminalNode;
    database(): DatabaseContext;
    DESCRIBE(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DescribeTableContext extends ParserRuleContext {
    table(): TableContext;
    DESCRIBE(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class InsertContext extends ParserRuleContext {
    table(): TableContext;
    query(): QueryContext;
    INSERT(): TerminalNode | undefined;
    UPSERT(): TerminalNode | undefined;
    INTO(): TerminalNode | undefined;
    OVERWRITE(): TerminalNode | undefined;
    hints(): HintsContext | undefined;
    partition(): PartitionContext | undefined;
    columns(): ColumnsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PartitionContext extends ParserRuleContext {
    PARTITION(): TerminalNode;
    columnAssignments(): ColumnAssignmentsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class InsertMultipleContext extends ParserRuleContext {
    end(): EndContext;
    executeStatementSet(): ExecuteStatementSetContext | undefined;
    beginStatementSet(): BeginStatementSetContext | undefined;
    insert(): InsertContext[];
    insert(i: number): InsertContext;
    statementEnd(): StatementEndContext[];
    statementEnd(i: number): StatementEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExecuteStatementSetContext extends ParserRuleContext {
    EXECUTE(): TerminalNode;
    STATEMENT(): TerminalNode;
    SET(): TerminalNode;
    BEGIN(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class BeginStatementSetContext extends ParserRuleContext {
    BEGIN(): TerminalNode;
    STATEMENT(): TerminalNode;
    SET(): TerminalNode;
    statementEnd(): StatementEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class UseContext extends ParserRuleContext {
    USE(): TerminalNode;
    CATALOG(): TerminalNode | undefined;
    catalog(): CatalogContext | undefined;
    database(): DatabaseContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ShowContext extends ParserRuleContext {
    SHOW(): TerminalNode;
    CATALOGS(): TerminalNode | undefined;
    CURRENT(): TerminalNode | undefined;
    CATALOG(): TerminalNode | undefined;
    DATABASES(): TerminalNode | undefined;
    DATABASE(): TerminalNode | undefined;
    TABLES(): TerminalNode | undefined;
    VIEWS(): TerminalNode | undefined;
    FUNCTIONS(): TerminalNode | undefined;
    USER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DdlStatementContext extends ParserRuleContext {
    create(): CreateContext | undefined;
    drop(): DropContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CreateContext extends ParserRuleContext {
    createTable(): CreateTableContext | undefined;
    createCatalog(): CreateCatalogContext | undefined;
    createDatabase(): CreateDatabaseContext | undefined;
    createFunction(): CreateFunctionContext | undefined;
    createView(): CreateViewContext | undefined;
    createMaterializedTable(): CreateMaterializedTableContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CreateTableContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    TEMPORARY(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    defineValues(): DefineValuesContext | undefined;
    comment(): CommentContext | undefined;
    partitionedBy(): PartitionedByContext | undefined;
    distributedBy(): DistributedByContext | undefined;
    withValues(): WithValuesContext | undefined;
    likeTable(): LikeTableContext | undefined;
    asTable(): AsTableContext | undefined;
    AS(): TerminalNode | undefined;
    query(): QueryContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CreateMaterializedTableContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    MATERIALIZED(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    AS(): TerminalNode;
    query(): QueryContext;
    freshness(): FreshnessContext | undefined;
    tableConstraint(): TableConstraintContext | undefined;
    comment(): CommentContext | undefined;
    partitionedBy(): PartitionedByContext | undefined;
    withValues(): WithValuesContext | undefined;
    refreshMode(): RefreshModeContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DefineValuesContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    tableElement(): TableElementContext[];
    tableElement(i: number): TableElementContext;
    R_PARENTHESIS(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PartitionedByContext extends ParserRuleContext {
    PARTITIONED(): TerminalNode;
    BY(): TerminalNode;
    columns(): ColumnsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DistributedByContext extends ParserRuleContext {
    DISTRIBUTED(): TerminalNode;
    BY(): TerminalNode | undefined;
    columns(): ColumnsContext | undefined;
    intoBuckets(): IntoBucketsContext | undefined;
    HASH(): TerminalNode | undefined;
    RANGE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class IntoBucketsContext extends ParserRuleContext {
    INTO(): TerminalNode;
    REAL_LITERAL(): TerminalNode;
    BUCKETS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WithValuesContext extends ParserRuleContext {
    WITH(): TerminalNode;
    valueAssignments(): ValueAssignmentsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LikeTableContext extends ParserRuleContext {
    LIKE(): TerminalNode;
    table(): TableContext;
    likeConfig(): LikeConfigContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AsTableContext extends ParserRuleContext {
    AS(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    hints(): HintsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class FreshnessContext extends ParserRuleContext {
    FRESHNESS(): TerminalNode;
    EQUAL(): TerminalNode;
    INTERVAL(): TerminalNode;
    string(): StringContext;
    SECOND(): TerminalNode | undefined;
    MINUTE(): TerminalNode | undefined;
    HOUR(): TerminalNode | undefined;
    DAY(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class RefreshModeContext extends ParserRuleContext {
    REFRESH_MODE(): TerminalNode;
    EQUAL(): TerminalNode;
    CONTINUOUS(): TerminalNode | undefined;
    FULL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableElementContext extends ParserRuleContext {
    tableConstraint(): TableConstraintContext | undefined;
    watermarkDefinition(): WatermarkDefinitionContext | undefined;
    columnDefinition(): ColumnDefinitionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnDefinitionContext extends ParserRuleContext {
    _metadataKey: NameContext;
    columnName(): ColumnNameContext;
    type(): TypeContext | undefined;
    METADATA(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    columnConstraint(): ColumnConstraintContext | undefined;
    comment(): CommentContext | undefined;
    FROM(): TerminalNode | undefined;
    VIRTUAL(): TerminalNode | undefined;
    name(): NameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnConstraintContext extends ParserRuleContext {
    NULL(): TerminalNode | undefined;
    PRIMARY(): TerminalNode | undefined;
    KEY(): TerminalNode | undefined;
    CONSTRAINT(): TerminalNode | undefined;
    name(): NameContext | undefined;
    NOT(): TerminalNode | undefined;
    ENFORCED(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableConstraintContext extends ParserRuleContext {
    UNIQUE(): TerminalNode | undefined;
    columns(): ColumnsContext | undefined;
    PRIMARY(): TerminalNode | undefined;
    KEY(): TerminalNode | undefined;
    CONSTRAINT(): TerminalNode | undefined;
    name(): NameContext | undefined;
    ENFORCED(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WatermarkDefinitionContext extends ParserRuleContext {
    _rowtimeColumnName: NameContext;
    WATERMARK(): TerminalNode;
    FOR(): TerminalNode;
    AS(): TerminalNode;
    expr(): ExprContext;
    name(): NameContext[];
    name(i: number): NameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LikeConfigContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    likeOptions(): LikeOptionsContext;
    R_PARENTHESIS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LikeOptionsContext extends ParserRuleContext {
    likeOption(): LikeOptionContext[];
    likeOption(i: number): LikeOptionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LikeOptionContext extends ParserRuleContext {
    INCLUDING(): TerminalNode | undefined;
    EXCLUDING(): TerminalNode | undefined;
    ALL(): TerminalNode | undefined;
    CONSTRAINTS(): TerminalNode | undefined;
    DISTRIBUTION(): TerminalNode | undefined;
    PARTITIONS(): TerminalNode | undefined;
    OVERWRITING(): TerminalNode | undefined;
    GENERATED(): TerminalNode | undefined;
    OPTIONS(): TerminalNode | undefined;
    WATERMARKS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CreateCatalogContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    CATALOG(): TerminalNode;
    catalog(): CatalogContext;
    withValues(): WithValuesContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CreateDatabaseContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    DATABASE(): TerminalNode;
    database(): DatabaseContext;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    comment(): CommentContext | undefined;
    withValues(): WithValuesContext | undefined;
    asDatabase(): AsDatabaseContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AsDatabaseContext extends ParserRuleContext {
    AS(): TerminalNode;
    DATABASE(): TerminalNode;
    database(): DatabaseContext;
    includingTable(): IncludingTableContext | undefined;
    excludingTable(): ExcludingTableContext | undefined;
    hints(): HintsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class IncludingTableContext extends ParserRuleContext {
    INCLUDING(): TerminalNode;
    ALL(): TerminalNode | undefined;
    TABLES(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    name(): NameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExcludingTableContext extends ParserRuleContext {
    EXCLUDING(): TerminalNode;
    TABLE(): TerminalNode;
    name(): NameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CreateViewContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    VIEW(): TerminalNode;
    view(): ViewContext;
    AS(): TerminalNode;
    query(): QueryContext;
    OR(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    columns(): ColumnsContext | undefined;
    comment(): CommentContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CreateFunctionContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    FUNCTION(): TerminalNode;
    functionName(): FunctionNameContext;
    AS(): TerminalNode;
    alias(): AliasContext;
    OR(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    SYSTEM(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    LANGUAGE(): TerminalNode | undefined;
    JAVA(): TerminalNode | undefined;
    SCALA(): TerminalNode | undefined;
    PYTHON(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DropContext extends ParserRuleContext {
    dropTable(): DropTableContext | undefined;
    dropDatabase(): DropDatabaseContext | undefined;
    dropView(): DropViewContext | undefined;
    dropFunction(): DropFunctionContext | undefined;
    dropMaterializedTable(): DropMaterializedTableContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DropTableContext extends ParserRuleContext {
    DROP(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DropDatabaseContext extends ParserRuleContext {
    DROP(): TerminalNode;
    DATABASE(): TerminalNode;
    database(): DatabaseContext;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    RESTRICT(): TerminalNode | undefined;
    CASCADE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DropViewContext extends ParserRuleContext {
    DROP(): TerminalNode;
    VIEW(): TerminalNode;
    view(): ViewContext;
    TEMPORARY(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DropFunctionContext extends ParserRuleContext {
    DROP(): TerminalNode;
    FUNCTION(): TerminalNode;
    functionName(): FunctionNameContext;
    TEMPORARY(): TerminalNode | undefined;
    SYSTEM(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DropMaterializedTableContext extends ParserRuleContext {
    DROP(): TerminalNode;
    MATERIALIZED(): TerminalNode;
    TABLE(): TerminalNode;
    table(): TableContext;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AddJarContext extends ParserRuleContext {
    ADD(): TerminalNode;
    JAR(): TerminalNode;
    name(): NameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ModuleStatementContext extends ParserRuleContext {
    loadModule(): LoadModuleContext | undefined;
    unloadModule(): UnloadModuleContext | undefined;
    useModules(): UseModulesContext | undefined;
    showModules(): ShowModulesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LoadModuleContext extends ParserRuleContext {
    LOAD(): TerminalNode;
    MODULE(): TerminalNode;
    name(): NameContext;
    withValues(): WithValuesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class UnloadModuleContext extends ParserRuleContext {
    UNLOAD(): TerminalNode;
    MODULE(): TerminalNode;
    name(): NameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class UseModulesContext extends ParserRuleContext {
    USE(): TerminalNode;
    MODULES(): TerminalNode;
    name(): NameContext[];
    name(i: number): NameContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ShowModulesContext extends ParserRuleContext {
    SHOW(): TerminalNode;
    MODULES(): TerminalNode;
    FULL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TypeContext extends ParserRuleContext {
    typeName(): TypeNameContext;
    collectionsTypeName(): CollectionsTypeNameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TypeNameContext extends ParserRuleContext {
    _compoundIdentifier: ExprContext;
    sqlTypeName(): SqlTypeNameContext | undefined;
    expr(): ExprContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SqlTypeNameContext extends ParserRuleContext {
    char(): CharContext | undefined;
    varchar(): VarcharContext | undefined;
    BINARY(): TerminalNode | undefined;
    varbinary(): VarbinaryContext | undefined;
    TIME(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    R_PARENTHESIS(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    BYTES(): TerminalNode | undefined;
    decimal(): DecimalContext | undefined;
    COMMA(): TerminalNode | undefined;
    TINYINT(): TerminalNode | undefined;
    SMALLINT(): TerminalNode | undefined;
    INT(): TerminalNode | undefined;
    INTEGER(): TerminalNode | undefined;
    BIGINT(): TerminalNode | undefined;
    FLOAT(): TerminalNode | undefined;
    DOUBLE(): TerminalNode | undefined;
    PRECISION(): TerminalNode | undefined;
    DATE(): TerminalNode | undefined;
    TIMESTAMP(): TerminalNode | undefined;
    ZONE(): TerminalNode | undefined;
    WITHOUT(): TerminalNode | undefined;
    WITH(): TerminalNode | undefined;
    TIMESTAMP_LTZ(): TerminalNode | undefined;
    LOCAL(): TerminalNode | undefined;
    ARRAY(): TerminalNode | undefined;
    MULTISET(): TerminalNode | undefined;
    LESS(): TerminalNode | undefined;
    type(): TypeContext[];
    type(i: number): TypeContext;
    GREATER(): TerminalNode | undefined;
    MAP(): TerminalNode | undefined;
    rowType(): RowTypeContext | undefined;
    K_ANY(): TerminalNode | undefined;
    CURSOR(): TerminalNode | undefined;
    BOOLEAN(): TerminalNode | undefined;
    RAW(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    GEOMETRY(): TerminalNode | undefined;
    POINT(): TerminalNode | undefined;
    CURVE(): TerminalNode | undefined;
    LINESTRING(): TerminalNode | undefined;
    SURFACE(): TerminalNode | undefined;
    POLYGON(): TerminalNode | undefined;
    POLYHEDRALSURFACE(): TerminalNode | undefined;
    GEOMETRYCOLLECTION(): TerminalNode | undefined;
    MULTIPOINT(): TerminalNode | undefined;
    MULTICURVE(): TerminalNode | undefined;
    MULTILINESTRING(): TerminalNode | undefined;
    MULTISURFACE(): TerminalNode | undefined;
    MULTIPOLYGON(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CollectionsTypeNameContext extends ParserRuleContext {
    ARRAY(): TerminalNode | undefined;
    MULTISET(): TerminalNode | undefined;
    CHARACTER(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    IDENTIFIER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CharContext extends ParserRuleContext {
    CHAR(): TerminalNode | undefined;
    CHARACTER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class VarcharContext extends ParserRuleContext {
    char(): CharContext | undefined;
    VARYING(): TerminalNode | undefined;
    VARCHAR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DecimalContext extends ParserRuleContext {
    DECIMAL(): TerminalNode | undefined;
    DEC(): TerminalNode | undefined;
    NUMERIC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class VarbinaryContext extends ParserRuleContext {
    VARBINARY(): TerminalNode | undefined;
    BINARY(): TerminalNode | undefined;
    VARYING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class RowTypeContext extends ParserRuleContext {
    ROW(): TerminalNode;
    LESS(): TerminalNode | undefined;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    type(): TypeContext[];
    type(i: number): TypeContext;
    GREATER(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    alias(): AliasContext[];
    alias(i: number): AliasContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    NOT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SystemFunctionContext extends ParserRuleContext {
    USER(): TerminalNode | undefined;
    CURRENT_USER(): TerminalNode | undefined;
    SESSION_USER(): TerminalNode | undefined;
    SYSTEM_USER(): TerminalNode | undefined;
    CURRENT_PATH(): TerminalNode | undefined;
    CURRENT_ROLE(): TerminalNode | undefined;
    CURRENT_SCHEMA(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonFunctionContext extends ParserRuleContext {
    jsonExistsFunction(): JsonExistsFunctionContext | undefined;
    jsonValueFunction(): JsonValueFunctionContext | undefined;
    jsonQueryFunction(): JsonQueryFunctionContext | undefined;
    jsonObjectFunction(): JsonObjectFunctionContext | undefined;
    jsonObjectAggFunction(): JsonObjectAggFunctionContext | undefined;
    jsonArrayFunction(): JsonArrayFunctionContext | undefined;
    jsonArrayAggFunction(): JsonArrayAggFunctionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonExistsFunctionContext extends ParserRuleContext {
    JSON_EXISTS(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    jsonValue(): JsonValueContext;
    COMMA(): TerminalNode;
    path(): PathContext;
    R_PARENTHESIS(): TerminalNode;
    ON(): TerminalNode | undefined;
    ERROR(): TerminalNode[];
    ERROR(i: number): TerminalNode;
    TRUE(): TerminalNode | undefined;
    FALSE(): TerminalNode | undefined;
    UNKNOWN(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonValueFunctionContext extends ParserRuleContext {
    JSON_VALUE(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    jsonValue(): JsonValueContext;
    COMMA(): TerminalNode;
    path(): PathContext;
    R_PARENTHESIS(): TerminalNode;
    RETURNING(): TerminalNode | undefined;
    type(): TypeContext | undefined;
    ON(): TerminalNode[];
    ON(i: number): TerminalNode;
    EMPTY(): TerminalNode | undefined;
    ERROR(): TerminalNode[];
    ERROR(i: number): TerminalNode;
    NULL(): TerminalNode[];
    NULL(i: number): TerminalNode;
    DEFAULT(): TerminalNode[];
    DEFAULT(i: number): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonQueryFunctionContext extends ParserRuleContext {
    JSON_QUERY(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    jsonValue(): JsonValueContext;
    COMMA(): TerminalNode;
    path(): PathContext;
    R_PARENTHESIS(): TerminalNode;
    WRAPPER(): TerminalNode | undefined;
    ON(): TerminalNode[];
    ON(i: number): TerminalNode;
    EMPTY(): TerminalNode[];
    EMPTY(i: number): TerminalNode;
    ERROR(): TerminalNode[];
    ERROR(i: number): TerminalNode;
    WITHOUT(): TerminalNode | undefined;
    WITH(): TerminalNode | undefined;
    NULL(): TerminalNode[];
    NULL(i: number): TerminalNode;
    ARRAY(): TerminalNode[];
    ARRAY(i: number): TerminalNode;
    OBJECT(): TerminalNode[];
    OBJECT(i: number): TerminalNode;
    CONDITIONAL(): TerminalNode | undefined;
    UNCONDITIONAL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonValueContext extends ParserRuleContext {
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PathContext extends ParserRuleContext {
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonObjectFunctionContext extends ParserRuleContext {
    JSON_OBJECT(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    jsonKeyVal(): JsonKeyValContext[];
    jsonKeyVal(i: number): JsonKeyValContext;
    R_PARENTHESIS(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    nullBehavior(): NullBehaviorContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonObjectAggFunctionContext extends ParserRuleContext {
    JSON_OBJECT(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    jsonKeyVal(): JsonKeyValContext;
    R_PARENTHESIS(): TerminalNode;
    nullBehavior(): NullBehaviorContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonArrayFunctionContext extends ParserRuleContext {
    JSON_OBJECT(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    jsonVal(): JsonValContext[];
    jsonVal(i: number): JsonValContext;
    R_PARENTHESIS(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    nullBehavior(): NullBehaviorContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonArrayAggFunctionContext extends ParserRuleContext {
    JSON_OBJECT(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    jsonVal(): JsonValContext;
    R_PARENTHESIS(): TerminalNode;
    orderBy(): OrderByContext | undefined;
    nullBehavior(): NullBehaviorContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonKeyValContext extends ParserRuleContext {
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    VALUE(): TerminalNode | undefined;
    KEY(): TerminalNode | undefined;
    FORMAT(): TerminalNode | undefined;
    JSON(): TerminalNode | undefined;
    COLON(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class JsonValContext extends ParserRuleContext {
    expr(): ExprContext;
    FORMAT(): TerminalNode | undefined;
    JSON(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class NullBehaviorContext extends ParserRuleContext {
    ON(): TerminalNode;
    NULL(): TerminalNode[];
    NULL(i: number): TerminalNode;
    ABSENT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TemporalFunctionContext extends ParserRuleContext {
    temporalOverlaps(): TemporalOverlapsContext | undefined;
    temporalDate(): TemporalDateContext | undefined;
    temporalTime(): TemporalTimeContext | undefined;
    temporalTimestamp(): TemporalTimestampContext | undefined;
    yearMonthInterval(): YearMonthIntervalContext | undefined;
    dayTimeInterval(): DayTimeIntervalContext | undefined;
    CURRENT_DATE(): TerminalNode | undefined;
    CURRENT_TIME(): TerminalNode | undefined;
    CURRENT_TIMESTAMP(): TerminalNode | undefined;
    LOCALTIME(): TerminalNode | undefined;
    LOCALTIMESTAMP(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TemporalOverlapsContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode[];
    L_PARENTHESIS(i: number): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    R_PARENTHESIS(): TerminalNode[];
    R_PARENTHESIS(i: number): TerminalNode;
    OVERLAPS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TemporalDateContext extends ParserRuleContext {
    DATE(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TemporalTimeContext extends ParserRuleContext {
    TIME(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TemporalTimestampContext extends ParserRuleContext {
    TIMESTAMP(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class YearMonthIntervalContext extends ParserRuleContext {
    INTERVAL(): TerminalNode;
    string(): StringContext;
    yearUnit(): YearUnitContext | undefined;
    monthUnit(): MonthUnitContext | undefined;
    TO(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DayTimeIntervalContext extends ParserRuleContext {
    INTERVAL(): TerminalNode;
    string(): StringContext;
    dayUnit(): DayUnitContext | undefined;
    hourUnit(): HourUnitContext | undefined;
    minuteUnit(): MinuteUnitContext | undefined;
    secondUnit(): SecondUnitContext | undefined;
    TO(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class YearUnitContext extends ParserRuleContext {
    YEAR(): TerminalNode | undefined;
    YEARS(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MonthUnitContext extends ParserRuleContext {
    MONTH(): TerminalNode | undefined;
    MONTHS(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DayUnitContext extends ParserRuleContext {
    DAY(): TerminalNode | undefined;
    DAYS(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class HourUnitContext extends ParserRuleContext {
    HOUR(): TerminalNode | undefined;
    HOURS(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MinuteUnitContext extends ParserRuleContext {
    MINUTE(): TerminalNode | undefined;
    MINUTES(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SecondUnitContext extends ParserRuleContext {
    SECOND(): TerminalNode | undefined;
    SECONDS(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TimeIntervalUnitContext extends ParserRuleContext {
    CENTURY(): TerminalNode | undefined;
    DAY(): TerminalNode | undefined;
    DECADE(): TerminalNode | undefined;
    DOW(): TerminalNode | undefined;
    DOY(): TerminalNode | undefined;
    EPOCH(): TerminalNode | undefined;
    HOUR(): TerminalNode | undefined;
    ISODOW(): TerminalNode | undefined;
    ISOYEAR(): TerminalNode | undefined;
    MICROSECOND(): TerminalNode | undefined;
    MILLISECOND(): TerminalNode | undefined;
    MILLENNIUM(): TerminalNode | undefined;
    MINUTE(): TerminalNode | undefined;
    MONTH(): TerminalNode | undefined;
    NANOSECOND(): TerminalNode | undefined;
    QUARTER(): TerminalNode | undefined;
    SECOND(): TerminalNode | undefined;
    WEEK(): TerminalNode | undefined;
    YEAR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TimePointUnitContext extends ParserRuleContext {
    DAY(): TerminalNode | undefined;
    FRAC_SECOND(): TerminalNode | undefined;
    HOUR(): TerminalNode | undefined;
    MICROSECOND(): TerminalNode | undefined;
    MINUTE(): TerminalNode | undefined;
    MONTH(): TerminalNode | undefined;
    NANOSECOND(): TerminalNode | undefined;
    QUARTER(): TerminalNode | undefined;
    SECOND(): TerminalNode | undefined;
    SQL_TSI_DAY(): TerminalNode | undefined;
    SQL_TSI_FRAC_SECOND(): TerminalNode | undefined;
    SQL_TSI_HOUR(): TerminalNode | undefined;
    SQL_TSI_MICROSECOND(): TerminalNode | undefined;
    SQL_TSI_MINUTE(): TerminalNode | undefined;
    SQL_TSI_MONTH(): TerminalNode | undefined;
    SQL_TSI_QUARTER(): TerminalNode | undefined;
    SQL_TSI_SECOND(): TerminalNode | undefined;
    SQL_TSI_WEEK(): TerminalNode | undefined;
    SQL_TSI_YEAR(): TerminalNode | undefined;
    WEEK(): TerminalNode | undefined;
    YEAR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AggregateWithinContext extends ParserRuleContext {
    WITHIN(): TerminalNode;
    GROUP(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    orderBy(): OrderByContext;
    R_PARENTHESIS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AggregateFilterContext extends ParserRuleContext {
    FILTER(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    WHERE(): TerminalNode;
    expr(): ExprContext;
    R_PARENTHESIS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AggregateNullsContext extends ParserRuleContext {
    RESPECT(): TerminalNode | undefined;
    NULLS(): TerminalNode;
    IGNORE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class OverWindowContext extends ParserRuleContext {
    OVER(): TerminalNode;
    window(): WindowContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExpressionsContext extends ParserRuleContext {
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ParenthesisExpressionsContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    R_PARENTHESIS(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ParenthesisQueryContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    query(): QueryContext;
    R_PARENTHESIS(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnAssignmentsContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    R_PARENTHESIS(): TerminalNode;
    columnAssignment(): ColumnAssignmentContext[];
    columnAssignment(i: number): ColumnAssignmentContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnAssignmentContext extends ParserRuleContext {
    columnName(): ColumnNameContext;
    EQUAL(): TerminalNode | undefined;
    literalValue(): LiteralValueContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ValueAssignmentsContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    R_PARENTHESIS(): TerminalNode;
    valueAssignment(): ValueAssignmentContext[];
    valueAssignment(i: number): ValueAssignmentContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ValueAssignmentContext extends ParserRuleContext {
    literalValue(): LiteralValueContext[];
    literalValue(i: number): LiteralValueContext;
    EQUAL(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnsContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    columnName(): ColumnNameContext[];
    columnName(i: number): ColumnNameContext;
    R_PARENTHESIS(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnsWithoutParenthesisContext extends ParserRuleContext {
    columnName(): ColumnNameContext[];
    columnName(i: number): ColumnNameContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CommentContext extends ParserRuleContext {
    COMMENT(): TerminalNode;
    string(): StringContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class OrderByContext extends ParserRuleContext {
    ORDER(): TerminalNode;
    BY(): TerminalNode;
    orderItems(): OrderItemsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class OrderItemsContext extends ParserRuleContext {
    orderItem(): OrderItemContext[];
    orderItem(i: number): OrderItemContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PartitionByContext extends ParserRuleContext {
    PARTITION(): TerminalNode;
    BY(): TerminalNode;
    expressions(): ExpressionsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MatchRecognizeContext extends ParserRuleContext {
    MATCH_RECOGNIZE(): TerminalNode;
    L_PARENTHESIS(): TerminalNode;
    patternMatch(): PatternMatchContext;
    defineMatch(): DefineMatchContext;
    R_PARENTHESIS(): TerminalNode;
    measures(): MeasuresContext | undefined;
    perMatch(): PerMatchContext | undefined;
    afterMatch(): AfterMatchContext | undefined;
    withinMatch(): WithinMatchContext | undefined;
    subsetMatch(): SubsetMatchContext | undefined;
    orderBy(): OrderByContext | undefined;
    partitionBy(): PartitionByContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MeasuresContext extends ParserRuleContext {
    MEASURES(): TerminalNode;
    measureColumns(): MeasureColumnsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MeasureColumnsContext extends ParserRuleContext {
    measureColumn(): MeasureColumnContext[];
    measureColumn(i: number): MeasureColumnContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PerMatchContext extends ParserRuleContext {
    ONE(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    PER(): TerminalNode;
    MATCH(): TerminalNode;
    ALL(): TerminalNode | undefined;
    ROWS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AfterMatchContext extends ParserRuleContext {
    AFTER(): TerminalNode;
    MATCH(): TerminalNode;
    SKIP_W(): TerminalNode | undefined;
    TO(): TerminalNode | undefined;
    NEXT(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    PAST(): TerminalNode | undefined;
    LAST(): TerminalNode | undefined;
    FIRST(): TerminalNode | undefined;
    name(): NameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PatternMatchContext extends ParserRuleContext {
    PATTERN(): TerminalNode;
    pattern(): PatternContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WithinMatchContext extends ParserRuleContext {
    WITHIN(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SubsetMatchContext extends ParserRuleContext {
    SUBSET(): TerminalNode;
    subsetItems(): SubsetItemsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SubsetItemsContext extends ParserRuleContext {
    subsetItem(): SubsetItemContext[];
    subsetItem(i: number): SubsetItemContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SubsetItemContext extends ParserRuleContext {
    name(): NameContext;
    EQUAL(): TerminalNode;
    aliases(): AliasesContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DefineMatchContext extends ParserRuleContext {
    DEFINE(): TerminalNode;
    defineItems(): DefineItemsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DefineItemsContext extends ParserRuleContext {
    defineItem(): DefineItemContext[];
    defineItem(i: number): DefineItemContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DefineItemContext extends ParserRuleContext {
    name(): NameContext;
    AS(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class MeasureColumnContext extends ParserRuleContext {
    expr(): ExprContext;
    AS(): TerminalNode;
    alias(): AliasContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PatternContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    patternTerm(): PatternTermContext[];
    patternTerm(i: number): PatternTermContext;
    R_PARENTHESIS(): TerminalNode;
    VERTICAL_BAR(): TerminalNode[];
    VERTICAL_BAR(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PatternTermContext extends ParserRuleContext {
    patternFactor(): PatternFactorContext[];
    patternFactor(i: number): PatternFactorContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PatternFactorContext extends ParserRuleContext {
    patternPrimary(): PatternPrimaryContext;
    patternQuantifier(): PatternQuantifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PatternPrimaryContext extends ParserRuleContext {
    name(): NameContext | undefined;
    DOLLAR_SIGN(): TerminalNode | undefined;
    CARET(): TerminalNode | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    pattern(): PatternContext[];
    pattern(i: number): PatternContext;
    L_BRACE_SLASH(): TerminalNode | undefined;
    R_BRACE_SLASH(): TerminalNode | undefined;
    PERMUTE(): TerminalNode | undefined;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PatternQuantifierContext extends ParserRuleContext {
    ASTERISK(): TerminalNode | undefined;
    STAR_QUESTION(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    PLUS_QUESTION(): TerminalNode | undefined;
    QUESTION(): TerminalNode | undefined;
    QUESTION_QUESTION(): TerminalNode | undefined;
    L_BRACE(): TerminalNode | undefined;
    REAL_LITERAL(): TerminalNode[];
    REAL_LITERAL(i: number): TerminalNode;
    COMMA(): TerminalNode | undefined;
    R_BRACE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AliasContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode | undefined;
    string(): StringContext | undefined;
    nonReservedKeywords(): NonReservedKeywordsContext | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    alias(): AliasContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AliasesContext extends ParserRuleContext {
    L_PARENTHESIS(): TerminalNode;
    alias(): AliasContext[];
    alias(i: number): AliasContext;
    R_PARENTHESIS(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class KeywordContext extends ParserRuleContext {
    nonReservedKeywords(): NonReservedKeywordsContext | undefined;
    reservedKeywords(): ReservedKeywordsContext | undefined;
    commonKeywords(): CommonKeywordsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AnyNameContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode | undefined;
    keyword(): KeywordContext | undefined;
    string(): StringContext | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    anyName(): AnyNameContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class AnyNonStringNameContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode | undefined;
    keyword(): KeywordContext | undefined;
    L_PARENTHESIS(): TerminalNode | undefined;
    anyNonStringName(): AnyNonStringNameContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ArrowWindowFunctionContext extends ParserRuleContext {
    COMPOUND_ARROW(): TerminalNode;
    DATA(): TerminalNode | undefined;
    TIMECOL(): TerminalNode | undefined;
    SLIDE(): TerminalNode | undefined;
    STEP(): TerminalNode | undefined;
    SIZE(): TerminalNode | undefined;
    GAP(): TerminalNode | undefined;
    IDENTIFIER(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    table(): TableContext | undefined;
    expr(): ExprContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CharsetIntroducerContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CharsetLiteralContext extends ParserRuleContext {
    charsetIntroducer(): CharsetIntroducerContext;
    string(): StringContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LiteralValueContext extends ParserRuleContext {
    REAL_LITERAL(): TerminalNode | undefined;
    string(): StringContext[];
    string(i: number): StringContext;
    charsetLiteral(): CharsetLiteralContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class WhenExprContext extends ParserRuleContext {
    WHEN(): TerminalNode;
    expr(): ExprContext;
    thenExpr(): ThenExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ThenExprContext extends ParserRuleContext {
    THEN(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ElseExprContext extends ParserRuleContext {
    ELSE(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CaseEndContext extends ParserRuleContext {
    END(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ArrayConstructContext extends ParserRuleContext {
    parenthesisExpressions(): ParenthesisExpressionsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CompareContext extends ParserRuleContext {
    EQUAL(): TerminalNode | undefined;
    NOT_EQUAL(): TerminalNode | undefined;
    GREATER(): TerminalNode | undefined;
    GREATER_OR_EQUAL(): TerminalNode | undefined;
    LESS(): TerminalNode | undefined;
    LESS_OR_EQUAL(): TerminalNode | undefined;
    IS_EQUAL_NULL(): TerminalNode | undefined;
    UNEQUAL(): TerminalNode | undefined;
    DOUBLE_EQUAL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LogicalBindContext extends ParserRuleContext {
    AND(): TerminalNode | undefined;
    OR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PredicateContext extends ParserRuleContext {
    _kind: Token;
    _lower: ValueExprContext;
    _upper: ValueExprContext;
    _escapeChar: Token;
    _right: ValueExprContext;
    AND(): TerminalNode | undefined;
    BETWEEN(): TerminalNode | undefined;
    valueExpr(): ValueExprContext[];
    valueExpr(i: number): ValueExprContext;
    NOT(): TerminalNode | undefined;
    ASYMMETRIC(): TerminalNode | undefined;
    SYMMETRIC(): TerminalNode | undefined;
    parenthesisExpressions(): ParenthesisExpressionsContext | undefined;
    IN(): TerminalNode | undefined;
    parenthesisQuery(): ParenthesisQueryContext | undefined;
    LIKE(): TerminalNode | undefined;
    ESCAPE(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    TO(): TerminalNode | undefined;
    SIMILAR(): TerminalNode | undefined;
    IS(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    TRUE(): TerminalNode | undefined;
    FALSE(): TerminalNode | undefined;
    UNKNOWN(): TerminalNode | undefined;
    FROM(): TerminalNode | undefined;
    DISTINCT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExprContext extends ParserRuleContext {
    booleanExpr(): BooleanExprContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class BooleanExprContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: BooleanExprContext): void;
}
export declare class LogicalNotContext extends BooleanExprContext {
    NOT(): TerminalNode;
    booleanExpr(): BooleanExprContext;
    constructor(ctx: BooleanExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ExistsContext extends BooleanExprContext {
    parenthesisQuery(): ParenthesisQueryContext;
    EXISTS(): TerminalNode | undefined;
    UNIQUE(): TerminalNode | undefined;
    constructor(ctx: BooleanExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PredicatedContext extends BooleanExprContext {
    valueExpr(): ValueExprContext;
    predicate(): PredicateContext | undefined;
    constructor(ctx: BooleanExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class LogicalBinaryContext extends BooleanExprContext {
    _left: BooleanExprContext;
    _operator: LogicalBindContext;
    _right: BooleanExprContext;
    booleanExpr(): BooleanExprContext[];
    booleanExpr(i: number): BooleanExprContext;
    logicalBind(): LogicalBindContext;
    constructor(ctx: BooleanExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ValueExprContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ValueExprContext): void;
}
export declare class ValueExpressionDefaultContext extends ValueExprContext {
    primaryExpr(): PrimaryExprContext;
    constructor(ctx: ValueExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ArithmeticUnaryContext extends ValueExprContext {
    _operator: Token;
    valueExpr(): ValueExprContext;
    SLASH(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    constructor(ctx: ValueExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ArithmeticBinaryContext extends ValueExprContext {
    _left: ValueExprContext;
    _operator: Token;
    _right: ValueExprContext;
    valueExpr(): ValueExprContext[];
    valueExpr(i: number): ValueExprContext;
    ASTERISK(): TerminalNode | undefined;
    PERCENTAGE(): TerminalNode | undefined;
    DIVIDE(): TerminalNode | undefined;
    VERTICAL_BAR(): TerminalNode | undefined;
    DOUBLE_VERTICAL_BAR(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    SLASH(): TerminalNode | undefined;
    CARET(): TerminalNode | undefined;
    constructor(ctx: ValueExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ComparisonContext extends ValueExprContext {
    _left: ValueExprContext;
    _operator: CompareContext;
    _right: ValueExprContext;
    valueExpr(): ValueExprContext[];
    valueExpr(i: number): ValueExprContext;
    compare(): CompareContext;
    constructor(ctx: ValueExprContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class SubQueryContext extends ParserRuleContext {
    parenthesisQuery(): ParenthesisQueryContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class FunctionCallContext extends ParserRuleContext {
    functionName(): FunctionNameContext;
    L_PARENTHESIS(): TerminalNode;
    R_PARENTHESIS(): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    aggregateNulls(): AggregateNullsContext | undefined;
    aggregateWithin(): AggregateWithinContext | undefined;
    aggregateFilter(): AggregateFilterContext | undefined;
    overWindow(): OverWindowContext | undefined;
    setQuantifier(): SetQuantifierContext | undefined;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class PrimaryExprContext extends ParserRuleContext {
    NULL(): TerminalNode | undefined;
    CURRENT_DATE(): TerminalNode | undefined;
    CURRENT_TIME(): TerminalNode | undefined;
    CURRENT_TIMESTAMP(): TerminalNode | undefined;
    LOCALTIME(): TerminalNode | undefined;
    LOCALTIMESTAMP(): TerminalNode | undefined;
    CASE(): TerminalNode | undefined;
    caseEnd(): CaseEndContext | undefined;
    whenExpr(): WhenExprContext[];
    whenExpr(i: number): WhenExprContext;
    elseExpr(): ElseExprContext | undefined;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    L_PARENTHESIS(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    type(): TypeContext | undefined;
    R_PARENTHESIS(): TerminalNode | undefined;
    CAST(): TerminalNode | undefined;
    TRY_CAST(): TerminalNode | undefined;
    TUMBLE(): TerminalNode | undefined;
    HOP(): TerminalNode | undefined;
    CUMULATE(): TerminalNode | undefined;
    SESSION(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    table(): TableContext | undefined;
    arrowWindowFunction(): ArrowWindowFunctionContext[];
    arrowWindowFunction(i: number): ArrowWindowFunctionContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    subQuery(): SubQueryContext | undefined;
    projectItems(): ProjectItemsContext | undefined;
    jsonFunction(): JsonFunctionContext | undefined;
    systemFunction(): SystemFunctionContext | undefined;
    temporalFunction(): TemporalFunctionContext | undefined;
    timePointUnit(): TimePointUnitContext | undefined;
    EXTRACT(): TerminalNode | undefined;
    timeIntervalUnit(): TimeIntervalUnitContext | undefined;
    FROM(): TerminalNode | undefined;
    valueExpr(): ValueExprContext[];
    valueExpr(i: number): ValueExprContext;
    TO(): TerminalNode | undefined;
    FLOOR(): TerminalNode | undefined;
    CEIL(): TerminalNode | undefined;
    POSITION(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    TRIM(): TerminalNode | undefined;
    BOTH(): TerminalNode | undefined;
    LEADING(): TerminalNode | undefined;
    TRAILING(): TerminalNode | undefined;
    OVERLAY(): TerminalNode | undefined;
    PLACING(): TerminalNode | undefined;
    FOR(): TerminalNode | undefined;
    SUBSTRING(): TerminalNode | undefined;
    SUBSTR(): TerminalNode | undefined;
    BIND_PARAMETER(): TerminalNode | undefined;
    functionCall(): FunctionCallContext | undefined;
    column(): ColumnContext | undefined;
    literalValue(): LiteralValueContext | undefined;
    arrayConstruct(): ArrayConstructContext | undefined;
    primaryExpr(): PrimaryExprContext | undefined;
    L_BRACKET(): TerminalNode | undefined;
    R_BRACKET(): TerminalNode | undefined;
    IS(): TerminalNode | undefined;
    JSON(): TerminalNode | undefined;
    VALUE(): TerminalNode | undefined;
    SCALAR(): TerminalNode | undefined;
    ARRAY(): TerminalNode | undefined;
    OBJECT(): TerminalNode | undefined;
    DOT(): TerminalNode | undefined;
    name(): NameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class StringContext extends ParserRuleContext {
    STRING_LITERAL(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class NameContext extends ParserRuleContext {
    anyName(): AnyNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnNameContext extends ParserRuleContext {
    anyNonStringName(): AnyNonStringNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableNameContext extends ParserRuleContext {
    anyNonStringName(): AnyNonStringNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DatabaseNameContext extends ParserRuleContext {
    anyNonStringName(): AnyNonStringNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CatalogNameContext extends ParserRuleContext {
    anyNonStringName(): AnyNonStringNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ViewNameContext extends ParserRuleContext {
    anyNonStringName(): AnyNonStringNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class FunctionNameContext extends ParserRuleContext {
    anyNonStringName(): AnyNonStringNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ColumnContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ColumnContext): void;
}
export declare class ColumnReferenceContext extends ColumnContext {
    columnName(): ColumnNameContext;
    constructor(ctx: ColumnContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class StarContext extends ColumnContext {
    ASTERISK(): TerminalNode;
    table(): TableContext | undefined;
    DOT(): TerminalNode | undefined;
    constructor(ctx: ColumnContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DereferenceContext extends ColumnContext {
    table(): TableContext;
    DOT(): TerminalNode;
    columnName(): ColumnNameContext;
    constructor(ctx: ColumnContext);
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ViewContext extends ParserRuleContext {
    viewName(): ViewNameContext;
    database(): DatabaseContext | undefined;
    DOT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class TableContext extends ParserRuleContext {
    tableName(): TableNameContext;
    database(): DatabaseContext | undefined;
    DOT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class DatabaseContext extends ParserRuleContext {
    databaseName(): DatabaseNameContext;
    catalog(): CatalogContext | undefined;
    DOT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CatalogContext extends ParserRuleContext {
    catalogName(): CatalogNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class ReservedKeywordsContext extends ParserRuleContext {
    ABS(): TerminalNode | undefined;
    ALL(): TerminalNode | undefined;
    ALLOCATE(): TerminalNode | undefined;
    ALLOW(): TerminalNode | undefined;
    ALTER(): TerminalNode | undefined;
    AND(): TerminalNode | undefined;
    K_ANY(): TerminalNode | undefined;
    ARE(): TerminalNode | undefined;
    ARRAY(): TerminalNode | undefined;
    ARRAY_MAX_CARDINALITY(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    ASENSITIVE(): TerminalNode | undefined;
    ASYMMETRIC(): TerminalNode | undefined;
    AT(): TerminalNode | undefined;
    ATOMIC(): TerminalNode | undefined;
    AUTHORIZATION(): TerminalNode | undefined;
    AUTO(): TerminalNode | undefined;
    AVG(): TerminalNode | undefined;
    BEGIN(): TerminalNode | undefined;
    BEGIN_FRAME(): TerminalNode | undefined;
    BEGIN_PARTITION(): TerminalNode | undefined;
    BETWEEN(): TerminalNode | undefined;
    BIGINT(): TerminalNode | undefined;
    BINARY(): TerminalNode | undefined;
    BIT(): TerminalNode | undefined;
    BLOB(): TerminalNode | undefined;
    BOOLEAN(): TerminalNode | undefined;
    BOTH(): TerminalNode | undefined;
    BY(): TerminalNode | undefined;
    CALL(): TerminalNode | undefined;
    CALLED(): TerminalNode | undefined;
    CARDINALITY(): TerminalNode | undefined;
    CASCADED(): TerminalNode | undefined;
    CASE(): TerminalNode | undefined;
    CAST(): TerminalNode | undefined;
    CEIL(): TerminalNode | undefined;
    CEILING(): TerminalNode | undefined;
    CHANGELOG_MODE(): TerminalNode | undefined;
    CHAR(): TerminalNode | undefined;
    CHARACTER(): TerminalNode | undefined;
    CHARACTER_LENGTH(): TerminalNode | undefined;
    CHAR_LENGTH(): TerminalNode | undefined;
    CHECK(): TerminalNode | undefined;
    CLASSIFIER(): TerminalNode | undefined;
    CLOB(): TerminalNode | undefined;
    CLOSE(): TerminalNode | undefined;
    COALESCE(): TerminalNode | undefined;
    COLLATE(): TerminalNode | undefined;
    COLLECT(): TerminalNode | undefined;
    COLUMN(): TerminalNode | undefined;
    COMMIT(): TerminalNode | undefined;
    CONDITION(): TerminalNode | undefined;
    CONNECT(): TerminalNode | undefined;
    CONSTRAINT(): TerminalNode | undefined;
    CONTAINS(): TerminalNode | undefined;
    CONVERT(): TerminalNode | undefined;
    CORR(): TerminalNode | undefined;
    CORRESPONDING(): TerminalNode | undefined;
    COUNT(): TerminalNode | undefined;
    COVAR_POP(): TerminalNode | undefined;
    COVAR_SAMP(): TerminalNode | undefined;
    CREATE(): TerminalNode | undefined;
    CROSS(): TerminalNode | undefined;
    CUBE(): TerminalNode | undefined;
    CUME_DIST(): TerminalNode | undefined;
    CURRENT(): TerminalNode | undefined;
    CURRENT_CATALOG(): TerminalNode | undefined;
    CURRENT_DATE(): TerminalNode | undefined;
    CURRENT_DEFAULT_TRANSFORM_GROUP(): TerminalNode | undefined;
    CURRENT_PATH(): TerminalNode | undefined;
    CURRENT_ROLE(): TerminalNode | undefined;
    CURRENT_ROW(): TerminalNode | undefined;
    CURRENT_SCHEMA(): TerminalNode | undefined;
    CURRENT_TIME(): TerminalNode | undefined;
    CURRENT_TIMESTAMP(): TerminalNode | undefined;
    CURRENT_TRANSFORM_GROUP_FOR_TYPE(): TerminalNode | undefined;
    CURRENT_USER(): TerminalNode | undefined;
    CURSOR(): TerminalNode | undefined;
    CYCLE(): TerminalNode | undefined;
    DATE(): TerminalNode | undefined;
    DAY(): TerminalNode | undefined;
    DEALLOCATE(): TerminalNode | undefined;
    DEC(): TerminalNode | undefined;
    DECIMAL(): TerminalNode | undefined;
    DECLARE(): TerminalNode | undefined;
    DEFAULT(): TerminalNode | undefined;
    DEFINE(): TerminalNode | undefined;
    DELETE(): TerminalNode | undefined;
    DENSE_RANK(): TerminalNode | undefined;
    DEREF(): TerminalNode | undefined;
    DESCRIBE(): TerminalNode | undefined;
    DETERMINISTIC(): TerminalNode | undefined;
    DISALLOW(): TerminalNode | undefined;
    DISCONNECT(): TerminalNode | undefined;
    DISTINCT(): TerminalNode | undefined;
    DOUBLE(): TerminalNode | undefined;
    DROP(): TerminalNode | undefined;
    DYNAMIC(): TerminalNode | undefined;
    EACH(): TerminalNode | undefined;
    ELEMENT(): TerminalNode | undefined;
    ELSE(): TerminalNode | undefined;
    EMPTY(): TerminalNode | undefined;
    END(): TerminalNode | undefined;
    END_EXEC(): TerminalNode | undefined;
    END_FRAME(): TerminalNode | undefined;
    END_PARTITION(): TerminalNode | undefined;
    EQUALS(): TerminalNode | undefined;
    ESCAPE(): TerminalNode | undefined;
    ESTIMATED_COST(): TerminalNode | undefined;
    EVERY(): TerminalNode | undefined;
    EXCEPT(): TerminalNode | undefined;
    EXEC(): TerminalNode | undefined;
    EXECUTE(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    EXP(): TerminalNode | undefined;
    EXPLAIN(): TerminalNode | undefined;
    EXTEND(): TerminalNode | undefined;
    EXTERNAL(): TerminalNode | undefined;
    EXTRACT(): TerminalNode | undefined;
    FALSE(): TerminalNode | undefined;
    FETCH(): TerminalNode | undefined;
    FILTER(): TerminalNode | undefined;
    FIRST_VALUE(): TerminalNode | undefined;
    FLOAT(): TerminalNode | undefined;
    FLOOR(): TerminalNode | undefined;
    FOR(): TerminalNode | undefined;
    FOREIGN(): TerminalNode | undefined;
    FRAME_ROW(): TerminalNode | undefined;
    FREE(): TerminalNode | undefined;
    FROM(): TerminalNode | undefined;
    FULL(): TerminalNode | undefined;
    FUNCTION(): TerminalNode | undefined;
    FUSION(): TerminalNode | undefined;
    GET(): TerminalNode | undefined;
    GLOB(): TerminalNode | undefined;
    GLOBAL(): TerminalNode | undefined;
    GRANT(): TerminalNode | undefined;
    GROUP(): TerminalNode | undefined;
    GROUPING(): TerminalNode | undefined;
    GROUPS(): TerminalNode | undefined;
    HAVING(): TerminalNode | undefined;
    HOLD(): TerminalNode | undefined;
    HOUR(): TerminalNode | undefined;
    IDENTITY(): TerminalNode | undefined;
    IMPORT(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    INDICATOR(): TerminalNode | undefined;
    INITIAL(): TerminalNode | undefined;
    INNER(): TerminalNode | undefined;
    INOUT(): TerminalNode | undefined;
    INSENSITIVE(): TerminalNode | undefined;
    INSERT(): TerminalNode | undefined;
    INT(): TerminalNode | undefined;
    INTEGER(): TerminalNode | undefined;
    INTERSECT(): TerminalNode | undefined;
    INTERSECTION(): TerminalNode | undefined;
    INTERVAL(): TerminalNode | undefined;
    INTO(): TerminalNode | undefined;
    IS(): TerminalNode | undefined;
    JOIN(): TerminalNode | undefined;
    JSON_ARRAY(): TerminalNode | undefined;
    JSON_ARRAYAGG(): TerminalNode | undefined;
    JSON_EXECUTION_PLAN(): TerminalNode | undefined;
    JSON_EXISTS(): TerminalNode | undefined;
    JSON_OBJECT(): TerminalNode | undefined;
    JSON_OBJECTAGG(): TerminalNode | undefined;
    JSON_QUERY(): TerminalNode | undefined;
    JSON_VALUE(): TerminalNode | undefined;
    LAG(): TerminalNode | undefined;
    LANGUAGE(): TerminalNode | undefined;
    LARGE(): TerminalNode | undefined;
    LAST_VALUE(): TerminalNode | undefined;
    LATERAL(): TerminalNode | undefined;
    LEAD(): TerminalNode | undefined;
    LEADING(): TerminalNode | undefined;
    LEFT(): TerminalNode | undefined;
    LIKE(): TerminalNode | undefined;
    LIKE_REGEX(): TerminalNode | undefined;
    LIMIT(): TerminalNode | undefined;
    LN(): TerminalNode | undefined;
    LOCAL(): TerminalNode | undefined;
    LOCALTIME(): TerminalNode | undefined;
    LOCALTIMESTAMP(): TerminalNode | undefined;
    LOWER(): TerminalNode | undefined;
    MATCH(): TerminalNode | undefined;
    MATCHES(): TerminalNode | undefined;
    MATCH_NUMBER(): TerminalNode | undefined;
    MATCH_RECOGNIZE(): TerminalNode | undefined;
    MAX(): TerminalNode | undefined;
    MEASURES(): TerminalNode | undefined;
    MEMBER(): TerminalNode | undefined;
    MERGE(): TerminalNode | undefined;
    METHOD(): TerminalNode | undefined;
    MIN(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    MINUTE(): TerminalNode | undefined;
    MOD(): TerminalNode | undefined;
    MODIFIES(): TerminalNode | undefined;
    MODULE(): TerminalNode | undefined;
    MONTH(): TerminalNode | undefined;
    MULTISET(): TerminalNode | undefined;
    NATIONAL(): TerminalNode | undefined;
    NATURAL(): TerminalNode | undefined;
    NCHAR(): TerminalNode | undefined;
    NCLOB(): TerminalNode | undefined;
    NEW(): TerminalNode | undefined;
    NEXT(): TerminalNode | undefined;
    NO(): TerminalNode | undefined;
    NONE(): TerminalNode | undefined;
    NORMALIZE(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    NTH_VALUE(): TerminalNode | undefined;
    NTILE(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    NULLIF(): TerminalNode | undefined;
    NUMERIC(): TerminalNode | undefined;
    OCCURRENCES_REGEX(): TerminalNode | undefined;
    OCTET_LENGTH(): TerminalNode | undefined;
    OF(): TerminalNode | undefined;
    OFFSET(): TerminalNode | undefined;
    OLD(): TerminalNode | undefined;
    OMIT(): TerminalNode | undefined;
    ON(): TerminalNode | undefined;
    ONE(): TerminalNode | undefined;
    ONLY(): TerminalNode | undefined;
    OPEN(): TerminalNode | undefined;
    OPTIMIZE(): TerminalNode | undefined;
    OR(): TerminalNode | undefined;
    ORDER(): TerminalNode | undefined;
    OUT(): TerminalNode | undefined;
    OUTER(): TerminalNode | undefined;
    OVER(): TerminalNode | undefined;
    OVERLAPS(): TerminalNode | undefined;
    OVERLAY(): TerminalNode | undefined;
    PARAMETER(): TerminalNode | undefined;
    PARTITION(): TerminalNode | undefined;
    PATTERN(): TerminalNode | undefined;
    PER(): TerminalNode | undefined;
    PERCENT(): TerminalNode | undefined;
    PERCENTILE_CONT(): TerminalNode | undefined;
    PERCENTILE_DISC(): TerminalNode | undefined;
    PERCENT_RANK(): TerminalNode | undefined;
    PERIOD(): TerminalNode | undefined;
    PERMUTE(): TerminalNode | undefined;
    PORTION(): TerminalNode | undefined;
    POSITION(): TerminalNode | undefined;
    POSITION_REGEX(): TerminalNode | undefined;
    POWER(): TerminalNode | undefined;
    PRECEDES(): TerminalNode | undefined;
    PRECISION(): TerminalNode | undefined;
    PREPARE(): TerminalNode | undefined;
    PREV(): TerminalNode | undefined;
    PRIMARY(): TerminalNode | undefined;
    PROCEDURE(): TerminalNode | undefined;
    RANGE(): TerminalNode | undefined;
    RANK(): TerminalNode | undefined;
    READS(): TerminalNode | undefined;
    REAL(): TerminalNode | undefined;
    RECURSIVE(): TerminalNode | undefined;
    REF(): TerminalNode | undefined;
    REFERENCES(): TerminalNode | undefined;
    REFERENCING(): TerminalNode | undefined;
    REGR_AVGX(): TerminalNode | undefined;
    REGR_AVGY(): TerminalNode | undefined;
    REGR_COUNT(): TerminalNode | undefined;
    REGR_INTERCEPT(): TerminalNode | undefined;
    REGR_R2(): TerminalNode | undefined;
    REGR_SLOPE(): TerminalNode | undefined;
    REGR_SXX(): TerminalNode | undefined;
    REGR_SXY(): TerminalNode | undefined;
    REGR_SYY(): TerminalNode | undefined;
    RESET(): TerminalNode | undefined;
    RESULT(): TerminalNode | undefined;
    RETURN(): TerminalNode | undefined;
    RETURNS(): TerminalNode | undefined;
    REVOKE(): TerminalNode | undefined;
    RIGHT(): TerminalNode | undefined;
    ROLLBACK(): TerminalNode | undefined;
    ROLLUP(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    ROWS(): TerminalNode | undefined;
    ROW_NUMBER(): TerminalNode | undefined;
    RUNNING(): TerminalNode | undefined;
    SAVEPOINT(): TerminalNode | undefined;
    SCOPE(): TerminalNode | undefined;
    SCROLL(): TerminalNode | undefined;
    SEARCH(): TerminalNode | undefined;
    SECOND(): TerminalNode | undefined;
    SEEK(): TerminalNode | undefined;
    SELECT(): TerminalNode | undefined;
    SENSITIVE(): TerminalNode | undefined;
    SESSION_USER(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    SHOW(): TerminalNode | undefined;
    SIMILAR(): TerminalNode | undefined;
    SKIP_W(): TerminalNode | undefined;
    SMALLINT(): TerminalNode | undefined;
    SOME(): TerminalNode | undefined;
    SPECIFIC(): TerminalNode | undefined;
    SPECIFICTYPE(): TerminalNode | undefined;
    SQL(): TerminalNode | undefined;
    SQLEXCEPTION(): TerminalNode | undefined;
    SQLSTATE(): TerminalNode | undefined;
    SQLWARNING(): TerminalNode | undefined;
    SQRT(): TerminalNode | undefined;
    START(): TerminalNode | undefined;
    STATIC(): TerminalNode | undefined;
    STDDEV_POP(): TerminalNode | undefined;
    STDDEV_SAMP(): TerminalNode | undefined;
    STREAM(): TerminalNode | undefined;
    SUBMULTISET(): TerminalNode | undefined;
    SUBSET(): TerminalNode | undefined;
    SUBSTRING(): TerminalNode | undefined;
    SUBSTRING_REGEX(): TerminalNode | undefined;
    SUCCEEDS(): TerminalNode | undefined;
    SUM(): TerminalNode | undefined;
    SYMMETRIC(): TerminalNode | undefined;
    SYSTEM(): TerminalNode | undefined;
    SYSTEM_TIME(): TerminalNode | undefined;
    SYSTEM_USER(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    TABLESAMPLE(): TerminalNode | undefined;
    THEN(): TerminalNode | undefined;
    TIME(): TerminalNode | undefined;
    TIMESTAMP(): TerminalNode | undefined;
    TIMEZONE_HOUR(): TerminalNode | undefined;
    TIMEZONE_MINUTE(): TerminalNode | undefined;
    TINYINT(): TerminalNode | undefined;
    TO(): TerminalNode | undefined;
    TRAILING(): TerminalNode | undefined;
    TRANSLATE(): TerminalNode | undefined;
    TRANSLATE_REGEX(): TerminalNode | undefined;
    TRANSLATION(): TerminalNode | undefined;
    TREAT(): TerminalNode | undefined;
    TRIGGER(): TerminalNode | undefined;
    TRIM(): TerminalNode | undefined;
    TRIM_ARRRAY(): TerminalNode | undefined;
    TRUE(): TerminalNode | undefined;
    TRUNCATE(): TerminalNode | undefined;
    UESCAPE(): TerminalNode | undefined;
    UNION(): TerminalNode | undefined;
    UNIQUE(): TerminalNode | undefined;
    UNKNOWN(): TerminalNode | undefined;
    UNNEST(): TerminalNode | undefined;
    UPDATE(): TerminalNode | undefined;
    UPPER(): TerminalNode | undefined;
    UPSERT(): TerminalNode | undefined;
    USER(): TerminalNode | undefined;
    USING(): TerminalNode | undefined;
    VALUE(): TerminalNode | undefined;
    VALUES(): TerminalNode | undefined;
    VALUE_OF(): TerminalNode | undefined;
    VARBINARY(): TerminalNode | undefined;
    VARCHAR(): TerminalNode | undefined;
    VARYING(): TerminalNode | undefined;
    VAR_POP(): TerminalNode | undefined;
    VAR_SAMP(): TerminalNode | undefined;
    VERSIONING(): TerminalNode | undefined;
    WHEN(): TerminalNode | undefined;
    WHENEVER(): TerminalNode | undefined;
    WHERE(): TerminalNode | undefined;
    WIDTH_BUCKET(): TerminalNode | undefined;
    WINDOW(): TerminalNode | undefined;
    WITH(): TerminalNode | undefined;
    WITHIN(): TerminalNode | undefined;
    WITHOUT(): TerminalNode | undefined;
    YEAR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class NonReservedKeywordsContext extends ParserRuleContext {
    ABSENT(): TerminalNode | undefined;
    ACTION(): TerminalNode | undefined;
    ADD(): TerminalNode | undefined;
    AFTER(): TerminalNode | undefined;
    APPLY(): TerminalNode | undefined;
    ASC(): TerminalNode | undefined;
    CASCADE(): TerminalNode | undefined;
    CATALOG(): TerminalNode | undefined;
    CENTURY(): TerminalNode | undefined;
    CONDITIONAL(): TerminalNode | undefined;
    CONSTRAINTS(): TerminalNode | undefined;
    DATA(): TerminalNode | undefined;
    DATABASE(): TerminalNode | undefined;
    DAYS(): TerminalNode | undefined;
    DECADE(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    DOW(): TerminalNode | undefined;
    DOY(): TerminalNode | undefined;
    EPOCH(): TerminalNode | undefined;
    ERROR(): TerminalNode | undefined;
    EXCLUDING(): TerminalNode | undefined;
    FIRST(): TerminalNode | undefined;
    FORMAT(): TerminalNode | undefined;
    FRAC_SECOND(): TerminalNode | undefined;
    GENERATED(): TerminalNode | undefined;
    GEOMETRY(): TerminalNode | undefined;
    GO(): TerminalNode | undefined;
    HOP(): TerminalNode | undefined;
    HOURS(): TerminalNode | undefined;
    IGNORE(): TerminalNode | undefined;
    INCLUDING(): TerminalNode | undefined;
    ISODOW(): TerminalNode | undefined;
    ISOYEAR(): TerminalNode | undefined;
    JAVA(): TerminalNode | undefined;
    JSON(): TerminalNode | undefined;
    KEY(): TerminalNode | undefined;
    LAST(): TerminalNode | undefined;
    MAP(): TerminalNode | undefined;
    MICROSECOND(): TerminalNode | undefined;
    MILLENNIUM(): TerminalNode | undefined;
    MILLISECOND(): TerminalNode | undefined;
    MINUTES(): TerminalNode | undefined;
    MONTHS(): TerminalNode | undefined;
    NANOSECOND(): TerminalNode | undefined;
    NULLS(): TerminalNode | undefined;
    OBJECT(): TerminalNode | undefined;
    OPTIONS(): TerminalNode | undefined;
    ORDINALITY(): TerminalNode | undefined;
    PARTIAL(): TerminalNode | undefined;
    PAST(): TerminalNode | undefined;
    PIVOT(): TerminalNode | undefined;
    PLACING(): TerminalNode | undefined;
    PLAN(): TerminalNode | undefined;
    PRECEDING(): TerminalNode | undefined;
    QUARTER(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    RESPECT(): TerminalNode | undefined;
    RESTRICT(): TerminalNode | undefined;
    RETURNING(): TerminalNode | undefined;
    SCALAR(): TerminalNode | undefined;
    SECONDS(): TerminalNode | undefined;
    SESSION(): TerminalNode | undefined;
    SETS(): TerminalNode | undefined;
    SIZE(): TerminalNode | undefined;
    SQL_TSI_DAY(): TerminalNode | undefined;
    SQL_TSI_FRAC_SECOND(): TerminalNode | undefined;
    SQL_TSI_HOUR(): TerminalNode | undefined;
    SQL_TSI_MICROSECOND(): TerminalNode | undefined;
    SQL_TSI_MINUTE(): TerminalNode | undefined;
    SQL_TSI_MONTH(): TerminalNode | undefined;
    SQL_TSI_QUARTER(): TerminalNode | undefined;
    SQL_TSI_SECOND(): TerminalNode | undefined;
    SQL_TSI_WEEK(): TerminalNode | undefined;
    SQL_TSI_YEAR(): TerminalNode | undefined;
    STATEMENT(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    TUMBLE(): TerminalNode | undefined;
    UNCONDITIONAL(): TerminalNode | undefined;
    UNPIVOT(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    WEEK(): TerminalNode | undefined;
    WRAPPER(): TerminalNode | undefined;
    YEARS(): TerminalNode | undefined;
    ZONE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}
export declare class CommonKeywordsContext extends ParserRuleContext {
    ANALYZE(): TerminalNode | undefined;
    BYTES(): TerminalNode | undefined;
    CATALOGS(): TerminalNode | undefined;
    COMMENT(): TerminalNode | undefined;
    COMPUTE(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    CUMULATE(): TerminalNode | undefined;
    CURVE(): TerminalNode | undefined;
    DATABASES(): TerminalNode | undefined;
    ENFORCED(): TerminalNode | undefined;
    FUNCTIONS(): TerminalNode | undefined;
    GEOMETRYCOLLECTION(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    JAR(): TerminalNode | undefined;
    LINESTRING(): TerminalNode | undefined;
    LOAD(): TerminalNode | undefined;
    METADATA(): TerminalNode | undefined;
    MODULES(): TerminalNode | undefined;
    MULTICURVE(): TerminalNode | undefined;
    MULTILINESTRING(): TerminalNode | undefined;
    MULTIPOINT(): TerminalNode | undefined;
    MULTIPOLYGON(): TerminalNode | undefined;
    MULTISURFACE(): TerminalNode | undefined;
    OVERWRITE(): TerminalNode | undefined;
    OVERWRITING(): TerminalNode | undefined;
    PLAN_ADVICE(): TerminalNode | undefined;
    PARTITIONED(): TerminalNode | undefined;
    PARTITIONS(): TerminalNode | undefined;
    POINT(): TerminalNode | undefined;
    POLYHEDRALSURFACE(): TerminalNode | undefined;
    POLYGON(): TerminalNode | undefined;
    PYTHON(): TerminalNode | undefined;
    RAW(): TerminalNode | undefined;
    RENAME(): TerminalNode | undefined;
    SCALA(): TerminalNode | undefined;
    SLIDE(): TerminalNode | undefined;
    STEP(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    SUBSTR(): TerminalNode | undefined;
    SURFACE(): TerminalNode | undefined;
    TABLES(): TerminalNode | undefined;
    TIMECOL(): TerminalNode | undefined;
    TIMESTAMP_LTZ(): TerminalNode | undefined;
    TRY_CAST(): TerminalNode | undefined;
    UNLOAD(): TerminalNode | undefined;
    USE(): TerminalNode | undefined;
    VIEWS(): TerminalNode | undefined;
    VIRTUAL(): TerminalNode | undefined;
    WATERMARK(): TerminalNode | undefined;
    WATERMARKS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FlinkSQLParserListener): void;
    exitRule(listener: FlinkSQLParserListener): void;
    accept<Result>(visitor: FlinkSQLParserVisitor<Result>): Result;
}