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 { SqlBaseListener } from "./SqlBaseListener";
import { SqlBaseVisitor } from "./SqlBaseVisitor";
export declare class SqlBaseParser extends Parser {
    static readonly T__0 = 1;
    static readonly T__1 = 2;
    static readonly T__2 = 3;
    static readonly T__3 = 4;
    static readonly T__4 = 5;
    static readonly T__5 = 6;
    static readonly T__6 = 7;
    static readonly T__7 = 8;
    static readonly T__8 = 9;
    static readonly T__9 = 10;
    static readonly T__10 = 11;
    static readonly T__11 = 12;
    static readonly T__12 = 13;
    static readonly T__13 = 14;
    static readonly T__14 = 15;
    static readonly ADD = 16;
    static readonly AFTER = 17;
    static readonly ALL = 18;
    static readonly ALTER = 19;
    static readonly ANALYZE = 20;
    static readonly AND = 21;
    static readonly ANTI = 22;
    static readonly ANY = 23;
    static readonly ARCHIVE = 24;
    static readonly ARRAY = 25;
    static readonly AS = 26;
    static readonly ASC = 27;
    static readonly AT = 28;
    static readonly AUTHORIZATION = 29;
    static readonly BETWEEN = 30;
    static readonly BOTH = 31;
    static readonly BUCKET = 32;
    static readonly BUCKETS = 33;
    static readonly BY = 34;
    static readonly CACHE = 35;
    static readonly CASCADE = 36;
    static readonly CASE = 37;
    static readonly CAST = 38;
    static readonly CHANGE = 39;
    static readonly CHECK = 40;
    static readonly CLEAR = 41;
    static readonly CLUSTER = 42;
    static readonly CLUSTERED = 43;
    static readonly CODEGEN = 44;
    static readonly COLLATE = 45;
    static readonly COLLECTION = 46;
    static readonly COLUMN = 47;
    static readonly COLUMNS = 48;
    static readonly COMMENT = 49;
    static readonly COMMIT = 50;
    static readonly COMPACT = 51;
    static readonly COMPACTIONS = 52;
    static readonly COMPUTE = 53;
    static readonly CONCATENATE = 54;
    static readonly CONSTRAINT = 55;
    static readonly COST = 56;
    static readonly CREATE = 57;
    static readonly CROSS = 58;
    static readonly CUBE = 59;
    static readonly CURRENT = 60;
    static readonly CURRENT_DATE = 61;
    static readonly CURRENT_TIME = 62;
    static readonly CURRENT_TIMESTAMP = 63;
    static readonly CURRENT_USER = 64;
    static readonly DAY = 65;
    static readonly DATA = 66;
    static readonly DATABASE = 67;
    static readonly DATABASES = 68;
    static readonly DBPROPERTIES = 69;
    static readonly DEFINED = 70;
    static readonly DELETE = 71;
    static readonly DELIMITED = 72;
    static readonly DESC = 73;
    static readonly DESCRIBE = 74;
    static readonly DFS = 75;
    static readonly DIRECTORIES = 76;
    static readonly DIRECTORY = 77;
    static readonly DISTINCT = 78;
    static readonly DISTRIBUTE = 79;
    static readonly DIV = 80;
    static readonly DROP = 81;
    static readonly ELSE = 82;
    static readonly END = 83;
    static readonly ESCAPE = 84;
    static readonly ESCAPED = 85;
    static readonly EXCEPT = 86;
    static readonly EXCHANGE = 87;
    static readonly EXISTS = 88;
    static readonly EXPLAIN = 89;
    static readonly EXPORT = 90;
    static readonly EXTENDED = 91;
    static readonly EXTERNAL = 92;
    static readonly EXTRACT = 93;
    static readonly FALSE = 94;
    static readonly FETCH = 95;
    static readonly FIELDS = 96;
    static readonly FILTER = 97;
    static readonly FILEFORMAT = 98;
    static readonly FIRST = 99;
    static readonly FOLLOWING = 100;
    static readonly FOR = 101;
    static readonly FOREIGN = 102;
    static readonly FORMAT = 103;
    static readonly FORMATTED = 104;
    static readonly FROM = 105;
    static readonly FULL = 106;
    static readonly FUNCTION = 107;
    static readonly FUNCTIONS = 108;
    static readonly GLOBAL = 109;
    static readonly GRANT = 110;
    static readonly GROUP = 111;
    static readonly GROUPING = 112;
    static readonly HAVING = 113;
    static readonly HOUR = 114;
    static readonly IF = 115;
    static readonly IGNORE = 116;
    static readonly IMPORT = 117;
    static readonly IN = 118;
    static readonly INDEX = 119;
    static readonly INDEXES = 120;
    static readonly INNER = 121;
    static readonly INPATH = 122;
    static readonly INPUTFORMAT = 123;
    static readonly INSERT = 124;
    static readonly INTERSECT = 125;
    static readonly INTERVAL = 126;
    static readonly INTO = 127;
    static readonly IS = 128;
    static readonly ITEMS = 129;
    static readonly JOIN = 130;
    static readonly KEYS = 131;
    static readonly LAST = 132;
    static readonly LATERAL = 133;
    static readonly LAZY = 134;
    static readonly LEADING = 135;
    static readonly LEFT = 136;
    static readonly LIKE = 137;
    static readonly LIMIT = 138;
    static readonly LINES = 139;
    static readonly LIST = 140;
    static readonly LOAD = 141;
    static readonly LOCAL = 142;
    static readonly LOCATION = 143;
    static readonly LOCK = 144;
    static readonly LOCKS = 145;
    static readonly LOGICAL = 146;
    static readonly MACRO = 147;
    static readonly MAP = 148;
    static readonly MATCHED = 149;
    static readonly MERGE = 150;
    static readonly MINUTE = 151;
    static readonly MONTH = 152;
    static readonly MSCK = 153;
    static readonly NAMESPACE = 154;
    static readonly NAMESPACES = 155;
    static readonly NATURAL = 156;
    static readonly NO = 157;
    static readonly NOT = 158;
    static readonly NULL = 159;
    static readonly NULLS = 160;
    static readonly OF = 161;
    static readonly ON = 162;
    static readonly ONLY = 163;
    static readonly OPTION = 164;
    static readonly OPTIONS = 165;
    static readonly OR = 166;
    static readonly ORDER = 167;
    static readonly OUT = 168;
    static readonly OUTER = 169;
    static readonly OUTPUTFORMAT = 170;
    static readonly OVER = 171;
    static readonly OVERLAPS = 172;
    static readonly OVERLAY = 173;
    static readonly OVERWRITE = 174;
    static readonly PARTITION = 175;
    static readonly PARTITIONED = 176;
    static readonly PARTITIONS = 177;
    static readonly PERCENTLIT = 178;
    static readonly PIVOT = 179;
    static readonly PLACING = 180;
    static readonly POSITION = 181;
    static readonly PRECEDING = 182;
    static readonly PRIMARY = 183;
    static readonly PRINCIPALS = 184;
    static readonly PROPERTIES = 185;
    static readonly PURGE = 186;
    static readonly QUERY = 187;
    static readonly RANGE = 188;
    static readonly RECORDREADER = 189;
    static readonly RECORDWRITER = 190;
    static readonly RECOVER = 191;
    static readonly REDUCE = 192;
    static readonly REFERENCES = 193;
    static readonly REFRESH = 194;
    static readonly RENAME = 195;
    static readonly REPAIR = 196;
    static readonly REPLACE = 197;
    static readonly RESET = 198;
    static readonly RESPECT = 199;
    static readonly RESTRICT = 200;
    static readonly REVOKE = 201;
    static readonly RIGHT = 202;
    static readonly RLIKE = 203;
    static readonly ROLE = 204;
    static readonly ROLES = 205;
    static readonly ROLLBACK = 206;
    static readonly ROLLUP = 207;
    static readonly ROW = 208;
    static readonly ROWS = 209;
    static readonly SECOND = 210;
    static readonly SCHEMA = 211;
    static readonly SELECT = 212;
    static readonly SEMI = 213;
    static readonly SEPARATED = 214;
    static readonly SERDE = 215;
    static readonly SERDEPROPERTIES = 216;
    static readonly SESSION_USER = 217;
    static readonly SET = 218;
    static readonly SETMINUS = 219;
    static readonly SETS = 220;
    static readonly SHOW = 221;
    static readonly SKEWED = 222;
    static readonly SOME = 223;
    static readonly SORT = 224;
    static readonly SORTED = 225;
    static readonly START = 226;
    static readonly STATISTICS = 227;
    static readonly STORED = 228;
    static readonly STRATIFY = 229;
    static readonly STRUCT = 230;
    static readonly SUBSTR = 231;
    static readonly SUBSTRING = 232;
    static readonly SYNC = 233;
    static readonly TABLE = 234;
    static readonly TABLES = 235;
    static readonly TABLESAMPLE = 236;
    static readonly TBLPROPERTIES = 237;
    static readonly TEMPORARY = 238;
    static readonly TERMINATED = 239;
    static readonly THEN = 240;
    static readonly TIME = 241;
    static readonly TO = 242;
    static readonly TOUCH = 243;
    static readonly TRAILING = 244;
    static readonly TRANSACTION = 245;
    static readonly TRANSACTIONS = 246;
    static readonly TRANSFORM = 247;
    static readonly TRIM = 248;
    static readonly TRUE = 249;
    static readonly TRUNCATE = 250;
    static readonly TRY_CAST = 251;
    static readonly TYPE = 252;
    static readonly UNARCHIVE = 253;
    static readonly UNBOUNDED = 254;
    static readonly UNCACHE = 255;
    static readonly UNION = 256;
    static readonly UNIQUE = 257;
    static readonly UNKNOWN = 258;
    static readonly UNLOCK = 259;
    static readonly UNSET = 260;
    static readonly UPDATE = 261;
    static readonly USE = 262;
    static readonly USER = 263;
    static readonly USING = 264;
    static readonly VALUES = 265;
    static readonly VIEW = 266;
    static readonly VIEWS = 267;
    static readonly WHEN = 268;
    static readonly WHERE = 269;
    static readonly WINDOW = 270;
    static readonly WITH = 271;
    static readonly YEAR = 272;
    static readonly ZONE = 273;
    static readonly EQ = 274;
    static readonly NSEQ = 275;
    static readonly NEQ = 276;
    static readonly NEQJ = 277;
    static readonly LT = 278;
    static readonly LTE = 279;
    static readonly GT = 280;
    static readonly GTE = 281;
    static readonly PLUS = 282;
    static readonly MINUS = 283;
    static readonly ASTERISK = 284;
    static readonly SLASH = 285;
    static readonly PERCENT = 286;
    static readonly TILDE = 287;
    static readonly AMPERSAND = 288;
    static readonly PIPE = 289;
    static readonly CONCAT_PIPE = 290;
    static readonly HAT = 291;
    static readonly STRING = 292;
    static readonly BIGINT_LITERAL = 293;
    static readonly SMALLINT_LITERAL = 294;
    static readonly TINYINT_LITERAL = 295;
    static readonly INTEGER_VALUE = 296;
    static readonly EXPONENT_VALUE = 297;
    static readonly DECIMAL_VALUE = 298;
    static readonly FLOAT_LITERAL = 299;
    static readonly DOUBLE_LITERAL = 300;
    static readonly BIGDECIMAL_LITERAL = 301;
    static readonly IDENTIFIER = 302;
    static readonly BACKQUOTED_IDENTIFIER = 303;
    static readonly DOUBLEQUOTED_IDENTIFIER = 304;
    static readonly SIMPLE_COMMENT = 305;
    static readonly BRACKETED_COMMENT = 306;
    static readonly WS = 307;
    static readonly UNRECOGNIZED = 308;
    static readonly RULE_singleStatement = 0;
    static readonly RULE_singleExpression = 1;
    static readonly RULE_singleTableIdentifier = 2;
    static readonly RULE_singleMultipartIdentifier = 3;
    static readonly RULE_singleFunctionIdentifier = 4;
    static readonly RULE_singleDataType = 5;
    static readonly RULE_singleTableSchema = 6;
    static readonly RULE_statement = 7;
    static readonly RULE_configKey = 8;
    static readonly RULE_configValue = 9;
    static readonly RULE_unsupportedHiveNativeCommands = 10;
    static readonly RULE_createTableHeader = 11;
    static readonly RULE_replaceTableHeader = 12;
    static readonly RULE_bucketSpec = 13;
    static readonly RULE_skewSpec = 14;
    static readonly RULE_locationSpec = 15;
    static readonly RULE_commentSpec = 16;
    static readonly RULE_query = 17;
    static readonly RULE_insertInto = 18;
    static readonly RULE_partitionSpecLocation = 19;
    static readonly RULE_partitionSpec = 20;
    static readonly RULE_partitionVal = 21;
    static readonly RULE_namespace = 22;
    static readonly RULE_describeFuncName = 23;
    static readonly RULE_describeColName = 24;
    static readonly RULE_ctes = 25;
    static readonly RULE_namedQuery = 26;
    static readonly RULE_tableProvider = 27;
    static readonly RULE_createTableClauses = 28;
    static readonly RULE_tablePropertyList = 29;
    static readonly RULE_tableProperty = 30;
    static readonly RULE_tablePropertyKey = 31;
    static readonly RULE_tablePropertyValue = 32;
    static readonly RULE_constantList = 33;
    static readonly RULE_nestedConstantList = 34;
    static readonly RULE_createFileFormat = 35;
    static readonly RULE_fileFormat = 36;
    static readonly RULE_storageHandler = 37;
    static readonly RULE_resource = 38;
    static readonly RULE_dmlStatementNoWith = 39;
    static readonly RULE_queryOrganization = 40;
    static readonly RULE_multiInsertQueryBody = 41;
    static readonly RULE_queryTerm = 42;
    static readonly RULE_queryPrimary = 43;
    static readonly RULE_sortItem = 44;
    static readonly RULE_fromStatement = 45;
    static readonly RULE_fromStatementBody = 46;
    static readonly RULE_querySpecification = 47;
    static readonly RULE_transformClause = 48;
    static readonly RULE_selectClause = 49;
    static readonly RULE_setClause = 50;
    static readonly RULE_matchedClause = 51;
    static readonly RULE_notMatchedClause = 52;
    static readonly RULE_matchedAction = 53;
    static readonly RULE_notMatchedAction = 54;
    static readonly RULE_assignmentList = 55;
    static readonly RULE_assignment = 56;
    static readonly RULE_whereClause = 57;
    static readonly RULE_havingClause = 58;
    static readonly RULE_hint = 59;
    static readonly RULE_hintStatement = 60;
    static readonly RULE_fromClause = 61;
    static readonly RULE_aggregationClause = 62;
    static readonly RULE_groupByClause = 63;
    static readonly RULE_groupingAnalytics = 64;
    static readonly RULE_groupingElement = 65;
    static readonly RULE_groupingSet = 66;
    static readonly RULE_pivotClause = 67;
    static readonly RULE_pivotColumn = 68;
    static readonly RULE_pivotValue = 69;
    static readonly RULE_lateralView = 70;
    static readonly RULE_setQuantifier = 71;
    static readonly RULE_relation = 72;
    static readonly RULE_joinRelation = 73;
    static readonly RULE_joinType = 74;
    static readonly RULE_joinCriteria = 75;
    static readonly RULE_sample = 76;
    static readonly RULE_sampleMethod = 77;
    static readonly RULE_identifierList = 78;
    static readonly RULE_identifierSeq = 79;
    static readonly RULE_orderedIdentifierList = 80;
    static readonly RULE_orderedIdentifier = 81;
    static readonly RULE_identifierCommentList = 82;
    static readonly RULE_identifierComment = 83;
    static readonly RULE_relationPrimary = 84;
    static readonly RULE_inlineTable = 85;
    static readonly RULE_functionTable = 86;
    static readonly RULE_tableAlias = 87;
    static readonly RULE_rowFormat = 88;
    static readonly RULE_multipartIdentifierList = 89;
    static readonly RULE_multipartIdentifier = 90;
    static readonly RULE_tableIdentifier = 91;
    static readonly RULE_functionIdentifier = 92;
    static readonly RULE_namedExpression = 93;
    static readonly RULE_namedExpressionSeq = 94;
    static readonly RULE_partitionFieldList = 95;
    static readonly RULE_partitionField = 96;
    static readonly RULE_transform = 97;
    static readonly RULE_transformArgument = 98;
    static readonly RULE_expression = 99;
    static readonly RULE_expressionSeq = 100;
    static readonly RULE_booleanExpression = 101;
    static readonly RULE_predicate = 102;
    static readonly RULE_valueExpression = 103;
    static readonly RULE_primaryExpression = 104;
    static readonly RULE_constant = 105;
    static readonly RULE_comparisonOperator = 106;
    static readonly RULE_arithmeticOperator = 107;
    static readonly RULE_predicateOperator = 108;
    static readonly RULE_booleanValue = 109;
    static readonly RULE_interval = 110;
    static readonly RULE_errorCapturingMultiUnitsInterval = 111;
    static readonly RULE_multiUnitsInterval = 112;
    static readonly RULE_errorCapturingUnitToUnitInterval = 113;
    static readonly RULE_unitToUnitInterval = 114;
    static readonly RULE_intervalValue = 115;
    static readonly RULE_colPosition = 116;
    static readonly RULE_dataType = 117;
    static readonly RULE_qualifiedColTypeWithPositionList = 118;
    static readonly RULE_qualifiedColTypeWithPosition = 119;
    static readonly RULE_colTypeList = 120;
    static readonly RULE_colType = 121;
    static readonly RULE_complexColTypeList = 122;
    static readonly RULE_complexColType = 123;
    static readonly RULE_whenClause = 124;
    static readonly RULE_windowClause = 125;
    static readonly RULE_namedWindow = 126;
    static readonly RULE_windowSpec = 127;
    static readonly RULE_windowFrame = 128;
    static readonly RULE_frameBound = 129;
    static readonly RULE_qualifiedNameList = 130;
    static readonly RULE_functionName = 131;
    static readonly RULE_qualifiedName = 132;
    static readonly RULE_errorCapturingIdentifier = 133;
    static readonly RULE_errorCapturingIdentifierExtra = 134;
    static readonly RULE_identifier = 135;
    static readonly RULE_strictIdentifier = 136;
    static readonly RULE_quotedIdentifier = 137;
    static readonly RULE_number = 138;
    static readonly RULE_alterColumnAction = 139;
    static readonly RULE_ansiNonReserved = 140;
    static readonly RULE_strictNonReserved = 141;
    static readonly RULE_nonReserved = 142;
    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;
    backquoted_identifier: boolean;
    doublequoted_identifier: boolean;
    /**
     * When false, INTERSECT is given the greater precedence over the other set
     * operations (UNION, EXCEPT and MINUS) as per the SQL standard.
     */
    legacy_setops_precedence_enabled: boolean;
    /**
     * When false, a literal with an exponent would be converted into
     * double type rather than decimal type.
     */
    legacy_exponent_literal_as_decimal_enabled: boolean;
    /**
     * When true, the behavior of keywords follows ANSI SQL standard.
     */
    SQL_standard_keyword_behavior: boolean;
    constructor(input: TokenStream);
    singleStatement(): SingleStatementContext;
    singleExpression(): SingleExpressionContext;
    singleTableIdentifier(): SingleTableIdentifierContext;
    singleMultipartIdentifier(): SingleMultipartIdentifierContext;
    singleFunctionIdentifier(): SingleFunctionIdentifierContext;
    singleDataType(): SingleDataTypeContext;
    singleTableSchema(): SingleTableSchemaContext;
    statement(): StatementContext;
    configKey(): ConfigKeyContext;
    configValue(): ConfigValueContext;
    unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext;
    createTableHeader(): CreateTableHeaderContext;
    replaceTableHeader(): ReplaceTableHeaderContext;
    bucketSpec(): BucketSpecContext;
    skewSpec(): SkewSpecContext;
    locationSpec(): LocationSpecContext;
    commentSpec(): CommentSpecContext;
    query(): QueryContext;
    insertInto(): InsertIntoContext;
    partitionSpecLocation(): PartitionSpecLocationContext;
    partitionSpec(): PartitionSpecContext;
    partitionVal(): PartitionValContext;
    namespace(): NamespaceContext;
    describeFuncName(): DescribeFuncNameContext;
    describeColName(): DescribeColNameContext;
    ctes(): CtesContext;
    namedQuery(): NamedQueryContext;
    tableProvider(): TableProviderContext;
    createTableClauses(): CreateTableClausesContext;
    tablePropertyList(): TablePropertyListContext;
    tableProperty(): TablePropertyContext;
    tablePropertyKey(): TablePropertyKeyContext;
    tablePropertyValue(): TablePropertyValueContext;
    constantList(): ConstantListContext;
    nestedConstantList(): NestedConstantListContext;
    createFileFormat(): CreateFileFormatContext;
    fileFormat(): FileFormatContext;
    storageHandler(): StorageHandlerContext;
    resource(): ResourceContext;
    dmlStatementNoWith(): DmlStatementNoWithContext;
    queryOrganization(): QueryOrganizationContext;
    multiInsertQueryBody(): MultiInsertQueryBodyContext;
    queryTerm(): QueryTermContext;
    queryTerm(_p: number): QueryTermContext;
    queryPrimary(): QueryPrimaryContext;
    sortItem(): SortItemContext;
    fromStatement(): FromStatementContext;
    fromStatementBody(): FromStatementBodyContext;
    querySpecification(): QuerySpecificationContext;
    transformClause(): TransformClauseContext;
    selectClause(): SelectClauseContext;
    setClause(): SetClauseContext;
    matchedClause(): MatchedClauseContext;
    notMatchedClause(): NotMatchedClauseContext;
    matchedAction(): MatchedActionContext;
    notMatchedAction(): NotMatchedActionContext;
    assignmentList(): AssignmentListContext;
    assignment(): AssignmentContext;
    whereClause(): WhereClauseContext;
    havingClause(): HavingClauseContext;
    hint(): HintContext;
    hintStatement(): HintStatementContext;
    fromClause(): FromClauseContext;
    aggregationClause(): AggregationClauseContext;
    groupByClause(): GroupByClauseContext;
    groupingAnalytics(): GroupingAnalyticsContext;
    groupingElement(): GroupingElementContext;
    groupingSet(): GroupingSetContext;
    pivotClause(): PivotClauseContext;
    pivotColumn(): PivotColumnContext;
    pivotValue(): PivotValueContext;
    lateralView(): LateralViewContext;
    setQuantifier(): SetQuantifierContext;
    relation(): RelationContext;
    joinRelation(): JoinRelationContext;
    joinType(): JoinTypeContext;
    joinCriteria(): JoinCriteriaContext;
    sample(): SampleContext;
    sampleMethod(): SampleMethodContext;
    identifierList(): IdentifierListContext;
    identifierSeq(): IdentifierSeqContext;
    orderedIdentifierList(): OrderedIdentifierListContext;
    orderedIdentifier(): OrderedIdentifierContext;
    identifierCommentList(): IdentifierCommentListContext;
    identifierComment(): IdentifierCommentContext;
    relationPrimary(): RelationPrimaryContext;
    inlineTable(): InlineTableContext;
    functionTable(): FunctionTableContext;
    tableAlias(): TableAliasContext;
    rowFormat(): RowFormatContext;
    multipartIdentifierList(): MultipartIdentifierListContext;
    multipartIdentifier(): MultipartIdentifierContext;
    tableIdentifier(): TableIdentifierContext;
    functionIdentifier(): FunctionIdentifierContext;
    namedExpression(): NamedExpressionContext;
    namedExpressionSeq(): NamedExpressionSeqContext;
    partitionFieldList(): PartitionFieldListContext;
    partitionField(): PartitionFieldContext;
    transform(): TransformContext;
    transformArgument(): TransformArgumentContext;
    expression(): ExpressionContext;
    expressionSeq(): ExpressionSeqContext;
    booleanExpression(): BooleanExpressionContext;
    booleanExpression(_p: number): BooleanExpressionContext;
    predicate(): PredicateContext;
    valueExpression(): ValueExpressionContext;
    valueExpression(_p: number): ValueExpressionContext;
    primaryExpression(): PrimaryExpressionContext;
    primaryExpression(_p: number): PrimaryExpressionContext;
    constant(): ConstantContext;
    comparisonOperator(): ComparisonOperatorContext;
    arithmeticOperator(): ArithmeticOperatorContext;
    predicateOperator(): PredicateOperatorContext;
    booleanValue(): BooleanValueContext;
    interval(): IntervalContext;
    errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext;
    multiUnitsInterval(): MultiUnitsIntervalContext;
    errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext;
    unitToUnitInterval(): UnitToUnitIntervalContext;
    intervalValue(): IntervalValueContext;
    colPosition(): ColPositionContext;
    dataType(): DataTypeContext;
    qualifiedColTypeWithPositionList(): QualifiedColTypeWithPositionListContext;
    qualifiedColTypeWithPosition(): QualifiedColTypeWithPositionContext;
    colTypeList(): ColTypeListContext;
    colType(): ColTypeContext;
    complexColTypeList(): ComplexColTypeListContext;
    complexColType(): ComplexColTypeContext;
    whenClause(): WhenClauseContext;
    windowClause(): WindowClauseContext;
    namedWindow(): NamedWindowContext;
    windowSpec(): WindowSpecContext;
    windowFrame(): WindowFrameContext;
    frameBound(): FrameBoundContext;
    qualifiedNameList(): QualifiedNameListContext;
    functionName(): FunctionNameContext;
    qualifiedName(): QualifiedNameContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext;
    errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext;
    identifier(): IdentifierContext;
    strictIdentifier(): StrictIdentifierContext;
    quotedIdentifier(): QuotedIdentifierContext;
    number(): NumberContext;
    alterColumnAction(): AlterColumnActionContext;
    ansiNonReserved(): AnsiNonReservedContext;
    strictNonReserved(): StrictNonReservedContext;
    nonReserved(): NonReservedContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private queryTerm_sempred;
    private booleanExpression_sempred;
    private valueExpression_sempred;
    private primaryExpression_sempred;
    private identifier_sempred;
    private strictIdentifier_sempred;
    private quotedIdentifier_sempred;
    private number_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 SingleStatementContext extends ParserRuleContext {
    statement(): StatementContext;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SingleExpressionContext extends ParserRuleContext {
    namedExpression(): NamedExpressionContext;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SingleTableIdentifierContext extends ParserRuleContext {
    tableIdentifier(): TableIdentifierContext;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SingleMultipartIdentifierContext extends ParserRuleContext {
    multipartIdentifier(): MultipartIdentifierContext;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SingleFunctionIdentifierContext extends ParserRuleContext {
    functionIdentifier(): FunctionIdentifierContext;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SingleDataTypeContext extends ParserRuleContext {
    dataType(): DataTypeContext;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SingleTableSchemaContext extends ParserRuleContext {
    colTypeList(): ColTypeListContext;
    EOF(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class StatementContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: StatementContext): void;
}
export declare class StatementDefaultContext extends StatementContext {
    query(): QueryContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DmlStatementContext extends StatementContext {
    dmlStatementNoWith(): DmlStatementNoWithContext;
    ctes(): CtesContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class UseContext extends StatementContext {
    USE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    NAMESPACE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateNamespaceContext extends StatementContext {
    CREATE(): TerminalNode;
    namespace(): NamespaceContext;
    multipartIdentifier(): MultipartIdentifierContext;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    commentSpec(): CommentSpecContext[];
    commentSpec(i: number): CommentSpecContext;
    locationSpec(): LocationSpecContext[];
    locationSpec(i: number): LocationSpecContext;
    WITH(): TerminalNode[];
    WITH(i: number): TerminalNode;
    tablePropertyList(): TablePropertyListContext[];
    tablePropertyList(i: number): TablePropertyListContext;
    DBPROPERTIES(): TerminalNode[];
    DBPROPERTIES(i: number): TerminalNode;
    PROPERTIES(): TerminalNode[];
    PROPERTIES(i: number): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetNamespacePropertiesContext extends StatementContext {
    ALTER(): TerminalNode;
    namespace(): NamespaceContext;
    multipartIdentifier(): MultipartIdentifierContext;
    SET(): TerminalNode;
    tablePropertyList(): TablePropertyListContext;
    DBPROPERTIES(): TerminalNode | undefined;
    PROPERTIES(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetNamespaceLocationContext extends StatementContext {
    ALTER(): TerminalNode;
    namespace(): NamespaceContext;
    multipartIdentifier(): MultipartIdentifierContext;
    SET(): TerminalNode;
    locationSpec(): LocationSpecContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DropNamespaceContext extends StatementContext {
    DROP(): TerminalNode;
    namespace(): NamespaceContext;
    multipartIdentifier(): MultipartIdentifierContext;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    RESTRICT(): TerminalNode | undefined;
    CASCADE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowNamespacesContext extends StatementContext {
    _pattern: Token;
    SHOW(): TerminalNode;
    DATABASES(): TerminalNode | undefined;
    NAMESPACES(): TerminalNode | undefined;
    multipartIdentifier(): MultipartIdentifierContext | undefined;
    FROM(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    LIKE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateTableContext extends StatementContext {
    createTableHeader(): CreateTableHeaderContext;
    createTableClauses(): CreateTableClausesContext;
    colTypeList(): ColTypeListContext | undefined;
    tableProvider(): TableProviderContext | undefined;
    query(): QueryContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateTableLikeContext extends StatementContext {
    _target: TableIdentifierContext;
    _source: TableIdentifierContext;
    _tableProps: TablePropertyListContext;
    CREATE(): TerminalNode;
    TABLE(): TerminalNode;
    LIKE(): TerminalNode;
    tableIdentifier(): TableIdentifierContext[];
    tableIdentifier(i: number): TableIdentifierContext;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    tableProvider(): TableProviderContext[];
    tableProvider(i: number): TableProviderContext;
    rowFormat(): RowFormatContext[];
    rowFormat(i: number): RowFormatContext;
    createFileFormat(): CreateFileFormatContext[];
    createFileFormat(i: number): CreateFileFormatContext;
    locationSpec(): LocationSpecContext[];
    locationSpec(i: number): LocationSpecContext;
    TBLPROPERTIES(): TerminalNode[];
    TBLPROPERTIES(i: number): TerminalNode;
    tablePropertyList(): TablePropertyListContext[];
    tablePropertyList(i: number): TablePropertyListContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ReplaceTableContext extends StatementContext {
    replaceTableHeader(): ReplaceTableHeaderContext;
    createTableClauses(): CreateTableClausesContext;
    colTypeList(): ColTypeListContext | undefined;
    tableProvider(): TableProviderContext | undefined;
    query(): QueryContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AnalyzeContext extends StatementContext {
    ANALYZE(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    COMPUTE(): TerminalNode;
    STATISTICS(): TerminalNode;
    partitionSpec(): PartitionSpecContext | undefined;
    identifier(): IdentifierContext | undefined;
    FOR(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    identifierSeq(): IdentifierSeqContext | undefined;
    ALL(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AnalyzeTablesContext extends StatementContext {
    ANALYZE(): TerminalNode;
    TABLES(): TerminalNode;
    COMPUTE(): TerminalNode;
    STATISTICS(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext | undefined;
    identifier(): IdentifierContext | undefined;
    FROM(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AddTableColumnsContext extends StatementContext {
    _columns: QualifiedColTypeWithPositionListContext;
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    ADD(): TerminalNode;
    COLUMN(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    qualifiedColTypeWithPositionList(): QualifiedColTypeWithPositionListContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RenameTableColumnContext extends StatementContext {
    _table: MultipartIdentifierContext;
    _from: MultipartIdentifierContext;
    _to: ErrorCapturingIdentifierContext;
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    RENAME(): TerminalNode;
    COLUMN(): TerminalNode;
    TO(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext[];
    multipartIdentifier(i: number): MultipartIdentifierContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DropTableColumnsContext extends StatementContext {
    _columns: MultipartIdentifierListContext;
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    DROP(): TerminalNode;
    COLUMN(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    multipartIdentifierList(): MultipartIdentifierListContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RenameTableContext extends StatementContext {
    _from: MultipartIdentifierContext;
    _to: MultipartIdentifierContext;
    ALTER(): TerminalNode;
    RENAME(): TerminalNode;
    TO(): TerminalNode;
    TABLE(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    multipartIdentifier(): MultipartIdentifierContext[];
    multipartIdentifier(i: number): MultipartIdentifierContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetTablePropertiesContext extends StatementContext {
    ALTER(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    SET(): TerminalNode;
    TBLPROPERTIES(): TerminalNode;
    tablePropertyList(): TablePropertyListContext;
    TABLE(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class UnsetTablePropertiesContext extends StatementContext {
    ALTER(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    UNSET(): TerminalNode;
    TBLPROPERTIES(): TerminalNode;
    tablePropertyList(): TablePropertyListContext;
    TABLE(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AlterTableAlterColumnContext extends StatementContext {
    _table: MultipartIdentifierContext;
    _column: MultipartIdentifierContext;
    ALTER(): TerminalNode[];
    ALTER(i: number): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext[];
    multipartIdentifier(i: number): MultipartIdentifierContext;
    CHANGE(): TerminalNode | undefined;
    COLUMN(): TerminalNode | undefined;
    alterColumnAction(): AlterColumnActionContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class HiveChangeColumnContext extends StatementContext {
    _table: MultipartIdentifierContext;
    _colName: MultipartIdentifierContext;
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    CHANGE(): TerminalNode;
    colType(): ColTypeContext;
    multipartIdentifier(): MultipartIdentifierContext[];
    multipartIdentifier(i: number): MultipartIdentifierContext;
    partitionSpec(): PartitionSpecContext | undefined;
    COLUMN(): TerminalNode | undefined;
    colPosition(): ColPositionContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class HiveReplaceColumnsContext extends StatementContext {
    _table: MultipartIdentifierContext;
    _columns: QualifiedColTypeWithPositionListContext;
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    REPLACE(): TerminalNode;
    COLUMNS(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    qualifiedColTypeWithPositionList(): QualifiedColTypeWithPositionListContext;
    partitionSpec(): PartitionSpecContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetTableSerDeContext extends StatementContext {
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    SET(): TerminalNode;
    SERDE(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    partitionSpec(): PartitionSpecContext | undefined;
    WITH(): TerminalNode | undefined;
    SERDEPROPERTIES(): TerminalNode | undefined;
    tablePropertyList(): TablePropertyListContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AddTablePartitionContext extends StatementContext {
    ALTER(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    ADD(): TerminalNode;
    TABLE(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    partitionSpecLocation(): PartitionSpecLocationContext[];
    partitionSpecLocation(i: number): PartitionSpecLocationContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RenameTablePartitionContext extends StatementContext {
    _from: PartitionSpecContext;
    _to: PartitionSpecContext;
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    RENAME(): TerminalNode;
    TO(): TerminalNode;
    partitionSpec(): PartitionSpecContext[];
    partitionSpec(i: number): PartitionSpecContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DropTablePartitionsContext extends StatementContext {
    ALTER(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    DROP(): TerminalNode;
    partitionSpec(): PartitionSpecContext[];
    partitionSpec(i: number): PartitionSpecContext;
    TABLE(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    PURGE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetTableLocationContext extends StatementContext {
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    SET(): TerminalNode;
    locationSpec(): LocationSpecContext;
    partitionSpec(): PartitionSpecContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RecoverPartitionsContext extends StatementContext {
    ALTER(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    RECOVER(): TerminalNode;
    PARTITIONS(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DropTableContext extends StatementContext {
    DROP(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    PURGE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DropViewContext extends StatementContext {
    DROP(): TerminalNode;
    VIEW(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateViewContext extends StatementContext {
    CREATE(): TerminalNode;
    VIEW(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    AS(): TerminalNode;
    query(): QueryContext;
    OR(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    identifierCommentList(): IdentifierCommentListContext | undefined;
    commentSpec(): CommentSpecContext[];
    commentSpec(i: number): CommentSpecContext;
    PARTITIONED(): TerminalNode[];
    PARTITIONED(i: number): TerminalNode;
    ON(): TerminalNode[];
    ON(i: number): TerminalNode;
    identifierList(): IdentifierListContext[];
    identifierList(i: number): IdentifierListContext;
    TBLPROPERTIES(): TerminalNode[];
    TBLPROPERTIES(i: number): TerminalNode;
    tablePropertyList(): TablePropertyListContext[];
    tablePropertyList(i: number): TablePropertyListContext;
    GLOBAL(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateTempViewUsingContext extends StatementContext {
    CREATE(): TerminalNode;
    TEMPORARY(): TerminalNode;
    VIEW(): TerminalNode;
    tableIdentifier(): TableIdentifierContext;
    tableProvider(): TableProviderContext;
    OR(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    GLOBAL(): TerminalNode | undefined;
    colTypeList(): ColTypeListContext | undefined;
    OPTIONS(): TerminalNode | undefined;
    tablePropertyList(): TablePropertyListContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AlterViewQueryContext extends StatementContext {
    ALTER(): TerminalNode;
    VIEW(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    query(): QueryContext;
    AS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateFunctionContext extends StatementContext {
    _className: Token;
    CREATE(): TerminalNode;
    FUNCTION(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    AS(): TerminalNode;
    STRING(): TerminalNode;
    OR(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    USING(): TerminalNode | undefined;
    resource(): ResourceContext[];
    resource(i: number): ResourceContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DropFunctionContext extends StatementContext {
    DROP(): TerminalNode;
    FUNCTION(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    TEMPORARY(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ExplainContext extends StatementContext {
    EXPLAIN(): TerminalNode;
    statement(): StatementContext;
    LOGICAL(): TerminalNode | undefined;
    FORMATTED(): TerminalNode | undefined;
    EXTENDED(): TerminalNode | undefined;
    CODEGEN(): TerminalNode | undefined;
    COST(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowTablesContext extends StatementContext {
    _pattern: Token;
    SHOW(): TerminalNode;
    TABLES(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext | undefined;
    FROM(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    LIKE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowTableExtendedContext extends StatementContext {
    _ns: MultipartIdentifierContext;
    _pattern: Token;
    SHOW(): TerminalNode;
    TABLE(): TerminalNode;
    EXTENDED(): TerminalNode;
    LIKE(): TerminalNode;
    STRING(): TerminalNode;
    partitionSpec(): PartitionSpecContext | undefined;
    FROM(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    multipartIdentifier(): MultipartIdentifierContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowTblPropertiesContext extends StatementContext {
    _table: MultipartIdentifierContext;
    _key: TablePropertyKeyContext;
    SHOW(): TerminalNode;
    TBLPROPERTIES(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    tablePropertyKey(): TablePropertyKeyContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowColumnsContext extends StatementContext {
    _table: MultipartIdentifierContext;
    _ns: MultipartIdentifierContext;
    SHOW(): TerminalNode;
    COLUMNS(): TerminalNode;
    FROM(): TerminalNode[];
    FROM(i: number): TerminalNode;
    IN(): TerminalNode[];
    IN(i: number): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext[];
    multipartIdentifier(i: number): MultipartIdentifierContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowViewsContext extends StatementContext {
    _pattern: Token;
    SHOW(): TerminalNode;
    VIEWS(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext | undefined;
    FROM(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    LIKE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowPartitionsContext extends StatementContext {
    SHOW(): TerminalNode;
    PARTITIONS(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    partitionSpec(): PartitionSpecContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowFunctionsContext extends StatementContext {
    _pattern: Token;
    SHOW(): TerminalNode;
    FUNCTIONS(): TerminalNode;
    identifier(): IdentifierContext | undefined;
    multipartIdentifier(): MultipartIdentifierContext | undefined;
    LIKE(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowCreateTableContext extends StatementContext {
    SHOW(): TerminalNode;
    CREATE(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    AS(): TerminalNode | undefined;
    SERDE(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ShowCurrentNamespaceContext extends StatementContext {
    SHOW(): TerminalNode;
    CURRENT(): TerminalNode;
    NAMESPACE(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DescribeFunctionContext extends StatementContext {
    FUNCTION(): TerminalNode;
    describeFuncName(): DescribeFuncNameContext;
    DESC(): TerminalNode | undefined;
    DESCRIBE(): TerminalNode | undefined;
    EXTENDED(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DescribeNamespaceContext extends StatementContext {
    namespace(): NamespaceContext;
    multipartIdentifier(): MultipartIdentifierContext;
    DESC(): TerminalNode | undefined;
    DESCRIBE(): TerminalNode | undefined;
    EXTENDED(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DescribeRelationContext extends StatementContext {
    _option: Token;
    multipartIdentifier(): MultipartIdentifierContext;
    DESC(): TerminalNode | undefined;
    DESCRIBE(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    partitionSpec(): PartitionSpecContext | undefined;
    describeColName(): DescribeColNameContext | undefined;
    EXTENDED(): TerminalNode | undefined;
    FORMATTED(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DescribeQueryContext extends StatementContext {
    query(): QueryContext;
    DESC(): TerminalNode | undefined;
    DESCRIBE(): TerminalNode | undefined;
    QUERY(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CommentNamespaceContext extends StatementContext {
    _comment: Token;
    COMMENT(): TerminalNode;
    ON(): TerminalNode;
    namespace(): NamespaceContext;
    multipartIdentifier(): MultipartIdentifierContext;
    IS(): TerminalNode;
    STRING(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CommentTableContext extends StatementContext {
    _comment: Token;
    COMMENT(): TerminalNode;
    ON(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    IS(): TerminalNode;
    STRING(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RefreshTableContext extends StatementContext {
    REFRESH(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RefreshFunctionContext extends StatementContext {
    REFRESH(): TerminalNode;
    FUNCTION(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RefreshResourceContext extends StatementContext {
    REFRESH(): TerminalNode;
    STRING(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CacheTableContext extends StatementContext {
    _options: TablePropertyListContext;
    CACHE(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    LAZY(): TerminalNode | undefined;
    OPTIONS(): TerminalNode | undefined;
    query(): QueryContext | undefined;
    tablePropertyList(): TablePropertyListContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class UncacheTableContext extends StatementContext {
    UNCACHE(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    IF(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ClearCacheContext extends StatementContext {
    CLEAR(): TerminalNode;
    CACHE(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class LoadDataContext extends StatementContext {
    _path: Token;
    LOAD(): TerminalNode;
    DATA(): TerminalNode;
    INPATH(): TerminalNode;
    INTO(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    STRING(): TerminalNode;
    LOCAL(): TerminalNode | undefined;
    OVERWRITE(): TerminalNode | undefined;
    partitionSpec(): PartitionSpecContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TruncateTableContext extends StatementContext {
    TRUNCATE(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    partitionSpec(): PartitionSpecContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RepairTableContext extends StatementContext {
    _option: Token;
    MSCK(): TerminalNode;
    REPAIR(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    PARTITIONS(): TerminalNode | undefined;
    ADD(): TerminalNode | undefined;
    DROP(): TerminalNode | undefined;
    SYNC(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ManageResourceContext extends StatementContext {
    _op: Token;
    identifier(): IdentifierContext;
    ADD(): TerminalNode | undefined;
    LIST(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FailNativeCommandContext extends StatementContext {
    SET(): TerminalNode | undefined;
    ROLE(): TerminalNode | undefined;
    unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetTimeZoneContext extends StatementContext {
    _timezone: Token;
    SET(): TerminalNode;
    TIME(): TerminalNode;
    ZONE(): TerminalNode;
    interval(): IntervalContext | undefined;
    STRING(): TerminalNode | undefined;
    LOCAL(): TerminalNode | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetQuotedConfigurationContext extends StatementContext {
    SET(): TerminalNode;
    configKey(): ConfigKeyContext | undefined;
    EQ(): TerminalNode | undefined;
    configValue(): ConfigValueContext | undefined;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetConfigurationContext extends StatementContext {
    SET(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ResetQuotedConfigurationContext extends StatementContext {
    RESET(): TerminalNode;
    configKey(): ConfigKeyContext;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ResetConfigurationContext extends StatementContext {
    RESET(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ConfigKeyContext extends ParserRuleContext {
    quotedIdentifier(): QuotedIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ConfigValueContext extends ParserRuleContext {
    quotedIdentifier(): QuotedIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class UnsupportedHiveNativeCommandsContext extends ParserRuleContext {
    _kw1: Token;
    _kw2: Token;
    _kw3: Token;
    _kw4: Token;
    _kw5: Token;
    _kw6: Token;
    CREATE(): TerminalNode | undefined;
    ROLE(): TerminalNode | undefined;
    DROP(): TerminalNode | undefined;
    GRANT(): TerminalNode | undefined;
    REVOKE(): TerminalNode | undefined;
    SHOW(): TerminalNode | undefined;
    PRINCIPALS(): TerminalNode | undefined;
    ROLES(): TerminalNode | undefined;
    CURRENT(): TerminalNode | undefined;
    EXPORT(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    IMPORT(): TerminalNode | undefined;
    COMPACTIONS(): TerminalNode | undefined;
    TRANSACTIONS(): TerminalNode | undefined;
    INDEXES(): TerminalNode | undefined;
    LOCKS(): TerminalNode | undefined;
    INDEX(): TerminalNode | undefined;
    ALTER(): TerminalNode | undefined;
    LOCK(): TerminalNode | undefined;
    DATABASE(): TerminalNode | undefined;
    UNLOCK(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    MACRO(): TerminalNode | undefined;
    tableIdentifier(): TableIdentifierContext | undefined;
    NOT(): TerminalNode | undefined;
    CLUSTERED(): TerminalNode | undefined;
    BY(): TerminalNode | undefined;
    SORTED(): TerminalNode | undefined;
    SKEWED(): TerminalNode | undefined;
    STORED(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    DIRECTORIES(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    LOCATION(): TerminalNode | undefined;
    EXCHANGE(): TerminalNode | undefined;
    PARTITION(): TerminalNode | undefined;
    ARCHIVE(): TerminalNode | undefined;
    UNARCHIVE(): TerminalNode | undefined;
    TOUCH(): TerminalNode | undefined;
    COMPACT(): TerminalNode | undefined;
    partitionSpec(): PartitionSpecContext | undefined;
    CONCATENATE(): TerminalNode | undefined;
    FILEFORMAT(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    START(): TerminalNode | undefined;
    TRANSACTION(): TerminalNode | undefined;
    COMMIT(): TerminalNode | undefined;
    ROLLBACK(): TerminalNode | undefined;
    DFS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateTableHeaderContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    TEMPORARY(): TerminalNode | undefined;
    EXTERNAL(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ReplaceTableHeaderContext extends ParserRuleContext {
    REPLACE(): TerminalNode;
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    CREATE(): TerminalNode | undefined;
    OR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class BucketSpecContext extends ParserRuleContext {
    CLUSTERED(): TerminalNode;
    BY(): TerminalNode[];
    BY(i: number): TerminalNode;
    identifierList(): IdentifierListContext;
    INTO(): TerminalNode;
    INTEGER_VALUE(): TerminalNode;
    BUCKETS(): TerminalNode;
    SORTED(): TerminalNode | undefined;
    orderedIdentifierList(): OrderedIdentifierListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SkewSpecContext extends ParserRuleContext {
    SKEWED(): TerminalNode;
    BY(): TerminalNode;
    identifierList(): IdentifierListContext;
    ON(): TerminalNode;
    constantList(): ConstantListContext | undefined;
    nestedConstantList(): NestedConstantListContext | undefined;
    STORED(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    DIRECTORIES(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class LocationSpecContext extends ParserRuleContext {
    LOCATION(): TerminalNode;
    STRING(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CommentSpecContext extends ParserRuleContext {
    COMMENT(): TerminalNode;
    STRING(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QueryContext extends ParserRuleContext {
    queryTerm(): QueryTermContext;
    queryOrganization(): QueryOrganizationContext;
    ctes(): CtesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class InsertIntoContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: InsertIntoContext): void;
}
export declare class InsertOverwriteTableContext extends InsertIntoContext {
    INSERT(): TerminalNode;
    OVERWRITE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    TABLE(): TerminalNode | undefined;
    partitionSpec(): PartitionSpecContext | undefined;
    identifierList(): IdentifierListContext | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    constructor(ctx: InsertIntoContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class InsertIntoTableContext extends InsertIntoContext {
    INSERT(): TerminalNode;
    INTO(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    TABLE(): TerminalNode | undefined;
    partitionSpec(): PartitionSpecContext | undefined;
    IF(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    identifierList(): IdentifierListContext | undefined;
    constructor(ctx: InsertIntoContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class InsertOverwriteHiveDirContext extends InsertIntoContext {
    _path: Token;
    INSERT(): TerminalNode;
    OVERWRITE(): TerminalNode;
    DIRECTORY(): TerminalNode;
    STRING(): TerminalNode;
    LOCAL(): TerminalNode | undefined;
    rowFormat(): RowFormatContext | undefined;
    createFileFormat(): CreateFileFormatContext | undefined;
    constructor(ctx: InsertIntoContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class InsertOverwriteDirContext extends InsertIntoContext {
    _path: Token;
    _options: TablePropertyListContext;
    INSERT(): TerminalNode;
    OVERWRITE(): TerminalNode;
    DIRECTORY(): TerminalNode;
    tableProvider(): TableProviderContext;
    LOCAL(): TerminalNode | undefined;
    OPTIONS(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    tablePropertyList(): TablePropertyListContext | undefined;
    constructor(ctx: InsertIntoContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PartitionSpecLocationContext extends ParserRuleContext {
    partitionSpec(): PartitionSpecContext;
    locationSpec(): LocationSpecContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PartitionSpecContext extends ParserRuleContext {
    PARTITION(): TerminalNode;
    partitionVal(): PartitionValContext[];
    partitionVal(i: number): PartitionValContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PartitionValContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    EQ(): TerminalNode | undefined;
    constant(): ConstantContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NamespaceContext extends ParserRuleContext {
    NAMESPACE(): TerminalNode | undefined;
    DATABASE(): TerminalNode | undefined;
    SCHEMA(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DescribeFuncNameContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext | undefined;
    STRING(): TerminalNode | undefined;
    comparisonOperator(): ComparisonOperatorContext | undefined;
    arithmeticOperator(): ArithmeticOperatorContext | undefined;
    predicateOperator(): PredicateOperatorContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DescribeColNameContext extends ParserRuleContext {
    _identifier: IdentifierContext;
    _nameParts: IdentifierContext[];
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CtesContext extends ParserRuleContext {
    WITH(): TerminalNode;
    namedQuery(): NamedQueryContext[];
    namedQuery(i: number): NamedQueryContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NamedQueryContext extends ParserRuleContext {
    _name: ErrorCapturingIdentifierContext;
    _columnAliases: IdentifierListContext;
    query(): QueryContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext;
    AS(): TerminalNode | undefined;
    identifierList(): IdentifierListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TableProviderContext extends ParserRuleContext {
    USING(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateTableClausesContext extends ParserRuleContext {
    _options: TablePropertyListContext;
    _partitioning: PartitionFieldListContext;
    _tableProps: TablePropertyListContext;
    skewSpec(): SkewSpecContext[];
    skewSpec(i: number): SkewSpecContext;
    bucketSpec(): BucketSpecContext[];
    bucketSpec(i: number): BucketSpecContext;
    rowFormat(): RowFormatContext[];
    rowFormat(i: number): RowFormatContext;
    createFileFormat(): CreateFileFormatContext[];
    createFileFormat(i: number): CreateFileFormatContext;
    locationSpec(): LocationSpecContext[];
    locationSpec(i: number): LocationSpecContext;
    commentSpec(): CommentSpecContext[];
    commentSpec(i: number): CommentSpecContext;
    OPTIONS(): TerminalNode[];
    OPTIONS(i: number): TerminalNode;
    PARTITIONED(): TerminalNode[];
    PARTITIONED(i: number): TerminalNode;
    BY(): TerminalNode[];
    BY(i: number): TerminalNode;
    TBLPROPERTIES(): TerminalNode[];
    TBLPROPERTIES(i: number): TerminalNode;
    tablePropertyList(): TablePropertyListContext[];
    tablePropertyList(i: number): TablePropertyListContext;
    partitionFieldList(): PartitionFieldListContext[];
    partitionFieldList(i: number): PartitionFieldListContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TablePropertyListContext extends ParserRuleContext {
    tableProperty(): TablePropertyContext[];
    tableProperty(i: number): TablePropertyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TablePropertyContext extends ParserRuleContext {
    _key: TablePropertyKeyContext;
    _value: TablePropertyValueContext;
    tablePropertyKey(): TablePropertyKeyContext;
    tablePropertyValue(): TablePropertyValueContext | undefined;
    EQ(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TablePropertyKeyContext extends ParserRuleContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    STRING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TablePropertyValueContext extends ParserRuleContext {
    INTEGER_VALUE(): TerminalNode | undefined;
    DECIMAL_VALUE(): TerminalNode | undefined;
    booleanValue(): BooleanValueContext | undefined;
    STRING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ConstantListContext extends ParserRuleContext {
    constant(): ConstantContext[];
    constant(i: number): ConstantContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NestedConstantListContext extends ParserRuleContext {
    constantList(): ConstantListContext[];
    constantList(i: number): ConstantListContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CreateFileFormatContext extends ParserRuleContext {
    STORED(): TerminalNode;
    AS(): TerminalNode | undefined;
    fileFormat(): FileFormatContext | undefined;
    BY(): TerminalNode | undefined;
    storageHandler(): StorageHandlerContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FileFormatContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: FileFormatContext): void;
}
export declare class TableFileFormatContext extends FileFormatContext {
    _inFmt: Token;
    _outFmt: Token;
    INPUTFORMAT(): TerminalNode;
    OUTPUTFORMAT(): TerminalNode;
    STRING(): TerminalNode[];
    STRING(i: number): TerminalNode;
    constructor(ctx: FileFormatContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class GenericFileFormatContext extends FileFormatContext {
    identifier(): IdentifierContext;
    constructor(ctx: FileFormatContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class StorageHandlerContext extends ParserRuleContext {
    STRING(): TerminalNode;
    WITH(): TerminalNode | undefined;
    SERDEPROPERTIES(): TerminalNode | undefined;
    tablePropertyList(): TablePropertyListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ResourceContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    STRING(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DmlStatementNoWithContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: DmlStatementNoWithContext): void;
}
export declare class SingleInsertQueryContext extends DmlStatementNoWithContext {
    insertInto(): InsertIntoContext;
    queryTerm(): QueryTermContext;
    queryOrganization(): QueryOrganizationContext;
    constructor(ctx: DmlStatementNoWithContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MultiInsertQueryContext extends DmlStatementNoWithContext {
    fromClause(): FromClauseContext;
    multiInsertQueryBody(): MultiInsertQueryBodyContext[];
    multiInsertQueryBody(i: number): MultiInsertQueryBodyContext;
    constructor(ctx: DmlStatementNoWithContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DeleteFromTableContext extends DmlStatementNoWithContext {
    DELETE(): TerminalNode;
    FROM(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    tableAlias(): TableAliasContext;
    whereClause(): WhereClauseContext | undefined;
    constructor(ctx: DmlStatementNoWithContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class UpdateTableContext extends DmlStatementNoWithContext {
    UPDATE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    tableAlias(): TableAliasContext;
    setClause(): SetClauseContext;
    whereClause(): WhereClauseContext | undefined;
    constructor(ctx: DmlStatementNoWithContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MergeIntoTableContext extends DmlStatementNoWithContext {
    _target: MultipartIdentifierContext;
    _targetAlias: TableAliasContext;
    _source: MultipartIdentifierContext;
    _sourceQuery: QueryContext;
    _sourceAlias: TableAliasContext;
    _mergeCondition: BooleanExpressionContext;
    MERGE(): TerminalNode;
    INTO(): TerminalNode;
    USING(): TerminalNode;
    ON(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext[];
    multipartIdentifier(i: number): MultipartIdentifierContext;
    tableAlias(): TableAliasContext[];
    tableAlias(i: number): TableAliasContext;
    booleanExpression(): BooleanExpressionContext;
    query(): QueryContext | undefined;
    matchedClause(): MatchedClauseContext[];
    matchedClause(i: number): MatchedClauseContext;
    notMatchedClause(): NotMatchedClauseContext[];
    notMatchedClause(i: number): NotMatchedClauseContext;
    constructor(ctx: DmlStatementNoWithContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QueryOrganizationContext extends ParserRuleContext {
    _sortItem: SortItemContext;
    _order: SortItemContext[];
    _expression: ExpressionContext;
    _clusterBy: ExpressionContext[];
    _distributeBy: ExpressionContext[];
    _sort: SortItemContext[];
    _limit: ExpressionContext;
    ORDER(): TerminalNode | undefined;
    BY(): TerminalNode[];
    BY(i: number): TerminalNode;
    CLUSTER(): TerminalNode | undefined;
    DISTRIBUTE(): TerminalNode | undefined;
    SORT(): TerminalNode | undefined;
    windowClause(): WindowClauseContext | undefined;
    LIMIT(): TerminalNode | undefined;
    sortItem(): SortItemContext[];
    sortItem(i: number): SortItemContext;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    ALL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MultiInsertQueryBodyContext extends ParserRuleContext {
    insertInto(): InsertIntoContext;
    fromStatementBody(): FromStatementBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QueryTermContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: QueryTermContext): void;
}
export declare class QueryTermDefaultContext extends QueryTermContext {
    queryPrimary(): QueryPrimaryContext;
    constructor(ctx: QueryTermContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetOperationContext extends QueryTermContext {
    _left: QueryTermContext;
    _operator: Token;
    _right: QueryTermContext;
    queryTerm(): QueryTermContext[];
    queryTerm(i: number): QueryTermContext;
    INTERSECT(): TerminalNode | undefined;
    UNION(): TerminalNode | undefined;
    EXCEPT(): TerminalNode | undefined;
    SETMINUS(): TerminalNode | undefined;
    setQuantifier(): SetQuantifierContext | undefined;
    constructor(ctx: QueryTermContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QueryPrimaryContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: QueryPrimaryContext): void;
}
export declare class QueryPrimaryDefaultContext extends QueryPrimaryContext {
    querySpecification(): QuerySpecificationContext;
    constructor(ctx: QueryPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FromStmtContext extends QueryPrimaryContext {
    fromStatement(): FromStatementContext;
    constructor(ctx: QueryPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TableContext extends QueryPrimaryContext {
    TABLE(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    constructor(ctx: QueryPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class InlineTableDefault1Context extends QueryPrimaryContext {
    inlineTable(): InlineTableContext;
    constructor(ctx: QueryPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SubqueryContext extends QueryPrimaryContext {
    query(): QueryContext;
    constructor(ctx: QueryPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SortItemContext extends ParserRuleContext {
    _ordering: Token;
    _nullOrder: Token;
    expression(): ExpressionContext;
    NULLS(): TerminalNode | undefined;
    ASC(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    LAST(): TerminalNode | undefined;
    FIRST(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FromStatementContext extends ParserRuleContext {
    fromClause(): FromClauseContext;
    fromStatementBody(): FromStatementBodyContext[];
    fromStatementBody(i: number): FromStatementBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FromStatementBodyContext extends ParserRuleContext {
    transformClause(): TransformClauseContext | undefined;
    queryOrganization(): QueryOrganizationContext;
    whereClause(): WhereClauseContext | undefined;
    selectClause(): SelectClauseContext | undefined;
    lateralView(): LateralViewContext[];
    lateralView(i: number): LateralViewContext;
    aggregationClause(): AggregationClauseContext | undefined;
    havingClause(): HavingClauseContext | undefined;
    windowClause(): WindowClauseContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QuerySpecificationContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: QuerySpecificationContext): void;
}
export declare class TransformQuerySpecificationContext extends QuerySpecificationContext {
    transformClause(): TransformClauseContext;
    fromClause(): FromClauseContext | undefined;
    lateralView(): LateralViewContext[];
    lateralView(i: number): LateralViewContext;
    whereClause(): WhereClauseContext | undefined;
    aggregationClause(): AggregationClauseContext | undefined;
    havingClause(): HavingClauseContext | undefined;
    windowClause(): WindowClauseContext | undefined;
    constructor(ctx: QuerySpecificationContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RegularQuerySpecificationContext extends QuerySpecificationContext {
    selectClause(): SelectClauseContext;
    fromClause(): FromClauseContext | undefined;
    lateralView(): LateralViewContext[];
    lateralView(i: number): LateralViewContext;
    whereClause(): WhereClauseContext | undefined;
    aggregationClause(): AggregationClauseContext | undefined;
    havingClause(): HavingClauseContext | undefined;
    windowClause(): WindowClauseContext | undefined;
    constructor(ctx: QuerySpecificationContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TransformClauseContext extends ParserRuleContext {
    _kind: Token;
    _inRowFormat: RowFormatContext;
    _recordWriter: Token;
    _script: Token;
    _outRowFormat: RowFormatContext;
    _recordReader: Token;
    USING(): TerminalNode;
    STRING(): TerminalNode[];
    STRING(i: number): TerminalNode;
    SELECT(): TerminalNode | undefined;
    expressionSeq(): ExpressionSeqContext | undefined;
    TRANSFORM(): TerminalNode | undefined;
    MAP(): TerminalNode | undefined;
    REDUCE(): TerminalNode | undefined;
    RECORDWRITER(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    RECORDREADER(): TerminalNode | undefined;
    rowFormat(): RowFormatContext[];
    rowFormat(i: number): RowFormatContext;
    setQuantifier(): SetQuantifierContext | undefined;
    identifierSeq(): IdentifierSeqContext | undefined;
    colTypeList(): ColTypeListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SelectClauseContext extends ParserRuleContext {
    _hint: HintContext;
    _hints: HintContext[];
    SELECT(): TerminalNode;
    namedExpressionSeq(): NamedExpressionSeqContext;
    setQuantifier(): SetQuantifierContext | undefined;
    hint(): HintContext[];
    hint(i: number): HintContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetClauseContext extends ParserRuleContext {
    SET(): TerminalNode;
    assignmentList(): AssignmentListContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MatchedClauseContext extends ParserRuleContext {
    _matchedCond: BooleanExpressionContext;
    WHEN(): TerminalNode;
    MATCHED(): TerminalNode;
    THEN(): TerminalNode;
    matchedAction(): MatchedActionContext;
    AND(): TerminalNode | undefined;
    booleanExpression(): BooleanExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NotMatchedClauseContext extends ParserRuleContext {
    _notMatchedCond: BooleanExpressionContext;
    WHEN(): TerminalNode;
    NOT(): TerminalNode;
    MATCHED(): TerminalNode;
    THEN(): TerminalNode;
    notMatchedAction(): NotMatchedActionContext;
    AND(): TerminalNode | undefined;
    booleanExpression(): BooleanExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MatchedActionContext extends ParserRuleContext {
    DELETE(): TerminalNode | undefined;
    UPDATE(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    ASTERISK(): TerminalNode | undefined;
    assignmentList(): AssignmentListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NotMatchedActionContext extends ParserRuleContext {
    _columns: MultipartIdentifierListContext;
    INSERT(): TerminalNode;
    ASTERISK(): TerminalNode | undefined;
    VALUES(): TerminalNode | undefined;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    multipartIdentifierList(): MultipartIdentifierListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AssignmentListContext extends ParserRuleContext {
    assignment(): AssignmentContext[];
    assignment(i: number): AssignmentContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AssignmentContext extends ParserRuleContext {
    _key: MultipartIdentifierContext;
    _value: ExpressionContext;
    EQ(): TerminalNode;
    multipartIdentifier(): MultipartIdentifierContext;
    expression(): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class WhereClauseContext extends ParserRuleContext {
    WHERE(): TerminalNode;
    booleanExpression(): BooleanExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class HavingClauseContext extends ParserRuleContext {
    HAVING(): TerminalNode;
    booleanExpression(): BooleanExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class HintContext extends ParserRuleContext {
    _hintStatement: HintStatementContext;
    _hintStatements: HintStatementContext[];
    hintStatement(): HintStatementContext[];
    hintStatement(i: number): HintStatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class HintStatementContext extends ParserRuleContext {
    _hintName: IdentifierContext;
    _primaryExpression: PrimaryExpressionContext;
    _parameters: PrimaryExpressionContext[];
    identifier(): IdentifierContext;
    primaryExpression(): PrimaryExpressionContext[];
    primaryExpression(i: number): PrimaryExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FromClauseContext extends ParserRuleContext {
    FROM(): TerminalNode;
    relation(): RelationContext[];
    relation(i: number): RelationContext;
    lateralView(): LateralViewContext[];
    lateralView(i: number): LateralViewContext;
    pivotClause(): PivotClauseContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AggregationClauseContext extends ParserRuleContext {
    _groupByClause: GroupByClauseContext;
    _groupingExpressionsWithGroupingAnalytics: GroupByClauseContext[];
    _expression: ExpressionContext;
    _groupingExpressions: ExpressionContext[];
    _kind: Token;
    GROUP(): TerminalNode;
    BY(): TerminalNode;
    groupByClause(): GroupByClauseContext[];
    groupByClause(i: number): GroupByClauseContext;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    WITH(): TerminalNode | undefined;
    SETS(): TerminalNode | undefined;
    groupingSet(): GroupingSetContext[];
    groupingSet(i: number): GroupingSetContext;
    ROLLUP(): TerminalNode | undefined;
    CUBE(): TerminalNode | undefined;
    GROUPING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class GroupByClauseContext extends ParserRuleContext {
    groupingAnalytics(): GroupingAnalyticsContext | undefined;
    expression(): ExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class GroupingAnalyticsContext extends ParserRuleContext {
    groupingSet(): GroupingSetContext[];
    groupingSet(i: number): GroupingSetContext;
    ROLLUP(): TerminalNode | undefined;
    CUBE(): TerminalNode | undefined;
    GROUPING(): TerminalNode | undefined;
    SETS(): TerminalNode | undefined;
    groupingElement(): GroupingElementContext[];
    groupingElement(i: number): GroupingElementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class GroupingElementContext extends ParserRuleContext {
    groupingAnalytics(): GroupingAnalyticsContext | undefined;
    groupingSet(): GroupingSetContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class GroupingSetContext extends ParserRuleContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PivotClauseContext extends ParserRuleContext {
    _aggregates: NamedExpressionSeqContext;
    _pivotValue: PivotValueContext;
    _pivotValues: PivotValueContext[];
    PIVOT(): TerminalNode;
    FOR(): TerminalNode;
    pivotColumn(): PivotColumnContext;
    IN(): TerminalNode;
    namedExpressionSeq(): NamedExpressionSeqContext;
    pivotValue(): PivotValueContext[];
    pivotValue(i: number): PivotValueContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PivotColumnContext extends ParserRuleContext {
    _identifier: IdentifierContext;
    _identifiers: IdentifierContext[];
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PivotValueContext extends ParserRuleContext {
    expression(): ExpressionContext;
    identifier(): IdentifierContext | undefined;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class LateralViewContext extends ParserRuleContext {
    _tblName: IdentifierContext;
    _identifier: IdentifierContext;
    _colName: IdentifierContext[];
    LATERAL(): TerminalNode;
    VIEW(): TerminalNode;
    qualifiedName(): QualifiedNameContext;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    OUTER(): TerminalNode | undefined;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SetQuantifierContext extends ParserRuleContext {
    DISTINCT(): TerminalNode | undefined;
    ALL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RelationContext extends ParserRuleContext {
    relationPrimary(): RelationPrimaryContext;
    LATERAL(): TerminalNode | undefined;
    joinRelation(): JoinRelationContext[];
    joinRelation(i: number): JoinRelationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class JoinRelationContext extends ParserRuleContext {
    _right: RelationPrimaryContext;
    JOIN(): TerminalNode;
    relationPrimary(): RelationPrimaryContext;
    joinType(): JoinTypeContext | undefined;
    LATERAL(): TerminalNode | undefined;
    joinCriteria(): JoinCriteriaContext | undefined;
    NATURAL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class JoinTypeContext extends ParserRuleContext {
    INNER(): TerminalNode | undefined;
    CROSS(): TerminalNode | undefined;
    LEFT(): TerminalNode | undefined;
    OUTER(): TerminalNode | undefined;
    SEMI(): TerminalNode | undefined;
    RIGHT(): TerminalNode | undefined;
    FULL(): TerminalNode | undefined;
    ANTI(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class JoinCriteriaContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: JoinCriteriaContext): void;
}
export declare class JoinCriteriaOnContext extends JoinCriteriaContext {
    ON(): TerminalNode;
    booleanExpression(): BooleanExpressionContext;
    constructor(ctx: JoinCriteriaContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class JoinCriteriaUsingContext extends JoinCriteriaContext {
    USING(): TerminalNode;
    identifierList(): IdentifierListContext;
    constructor(ctx: JoinCriteriaContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SampleContext extends ParserRuleContext {
    TABLESAMPLE(): TerminalNode;
    sampleMethod(): SampleMethodContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SampleMethodContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: SampleMethodContext): void;
}
export declare class SampleByPercentileContext extends SampleMethodContext {
    _negativeSign: Token;
    _percentage: Token;
    PERCENTLIT(): TerminalNode;
    INTEGER_VALUE(): TerminalNode | undefined;
    DECIMAL_VALUE(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: SampleMethodContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SampleByRowsContext extends SampleMethodContext {
    expression(): ExpressionContext;
    ROWS(): TerminalNode;
    constructor(ctx: SampleMethodContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SampleByBucketContext extends SampleMethodContext {
    _sampleType: Token;
    _numerator: Token;
    _denominator: Token;
    OUT(): TerminalNode;
    OF(): TerminalNode;
    BUCKET(): TerminalNode;
    INTEGER_VALUE(): TerminalNode[];
    INTEGER_VALUE(i: number): TerminalNode;
    ON(): TerminalNode | undefined;
    identifier(): IdentifierContext | undefined;
    qualifiedName(): QualifiedNameContext | undefined;
    constructor(ctx: SampleMethodContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SampleByBytesContext extends SampleMethodContext {
    _bytes: ExpressionContext;
    expression(): ExpressionContext;
    constructor(ctx: SampleMethodContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IdentifierListContext extends ParserRuleContext {
    identifierSeq(): IdentifierSeqContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IdentifierSeqContext extends ParserRuleContext {
    _errorCapturingIdentifier: ErrorCapturingIdentifierContext;
    _ident: ErrorCapturingIdentifierContext[];
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class OrderedIdentifierListContext extends ParserRuleContext {
    orderedIdentifier(): OrderedIdentifierContext[];
    orderedIdentifier(i: number): OrderedIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class OrderedIdentifierContext extends ParserRuleContext {
    _ident: ErrorCapturingIdentifierContext;
    _ordering: Token;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext;
    ASC(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IdentifierCommentListContext extends ParserRuleContext {
    identifierComment(): IdentifierCommentContext[];
    identifierComment(i: number): IdentifierCommentContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IdentifierCommentContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    commentSpec(): CommentSpecContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RelationPrimaryContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: RelationPrimaryContext): void;
}
export declare class TableNameContext extends RelationPrimaryContext {
    multipartIdentifier(): MultipartIdentifierContext;
    tableAlias(): TableAliasContext;
    sample(): SampleContext | undefined;
    constructor(ctx: RelationPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AliasedQueryContext extends RelationPrimaryContext {
    query(): QueryContext;
    tableAlias(): TableAliasContext;
    sample(): SampleContext | undefined;
    constructor(ctx: RelationPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AliasedRelationContext extends RelationPrimaryContext {
    relation(): RelationContext;
    tableAlias(): TableAliasContext;
    sample(): SampleContext | undefined;
    constructor(ctx: RelationPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class InlineTableDefault2Context extends RelationPrimaryContext {
    inlineTable(): InlineTableContext;
    constructor(ctx: RelationPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TableValuedFunctionContext extends RelationPrimaryContext {
    functionTable(): FunctionTableContext;
    constructor(ctx: RelationPrimaryContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class InlineTableContext extends ParserRuleContext {
    VALUES(): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    tableAlias(): TableAliasContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FunctionTableContext extends ParserRuleContext {
    _funcName: FunctionNameContext;
    tableAlias(): TableAliasContext;
    functionName(): FunctionNameContext;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TableAliasContext extends ParserRuleContext {
    strictIdentifier(): StrictIdentifierContext | undefined;
    AS(): TerminalNode | undefined;
    identifierList(): IdentifierListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RowFormatContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: RowFormatContext): void;
}
export declare class RowFormatSerdeContext extends RowFormatContext {
    _name: Token;
    _props: TablePropertyListContext;
    ROW(): TerminalNode;
    FORMAT(): TerminalNode;
    SERDE(): TerminalNode;
    STRING(): TerminalNode;
    WITH(): TerminalNode | undefined;
    SERDEPROPERTIES(): TerminalNode | undefined;
    tablePropertyList(): TablePropertyListContext | undefined;
    constructor(ctx: RowFormatContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RowFormatDelimitedContext extends RowFormatContext {
    _fieldsTerminatedBy: Token;
    _escapedBy: Token;
    _collectionItemsTerminatedBy: Token;
    _keysTerminatedBy: Token;
    _linesSeparatedBy: Token;
    _nullDefinedAs: Token;
    ROW(): TerminalNode;
    FORMAT(): TerminalNode;
    DELIMITED(): TerminalNode;
    FIELDS(): TerminalNode | undefined;
    TERMINATED(): TerminalNode[];
    TERMINATED(i: number): TerminalNode;
    BY(): TerminalNode[];
    BY(i: number): TerminalNode;
    COLLECTION(): TerminalNode | undefined;
    ITEMS(): TerminalNode | undefined;
    MAP(): TerminalNode | undefined;
    KEYS(): TerminalNode | undefined;
    LINES(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    DEFINED(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    STRING(): TerminalNode[];
    STRING(i: number): TerminalNode;
    ESCAPED(): TerminalNode | undefined;
    constructor(ctx: RowFormatContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MultipartIdentifierListContext extends ParserRuleContext {
    multipartIdentifier(): MultipartIdentifierContext[];
    multipartIdentifier(i: number): MultipartIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MultipartIdentifierContext extends ParserRuleContext {
    _errorCapturingIdentifier: ErrorCapturingIdentifierContext;
    _parts: ErrorCapturingIdentifierContext[];
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TableIdentifierContext extends ParserRuleContext {
    _db: ErrorCapturingIdentifierContext;
    _table: ErrorCapturingIdentifierContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FunctionIdentifierContext extends ParserRuleContext {
    _db: ErrorCapturingIdentifierContext;
    _funcName: ErrorCapturingIdentifierContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NamedExpressionContext extends ParserRuleContext {
    _name: ErrorCapturingIdentifierContext;
    expression(): ExpressionContext;
    identifierList(): IdentifierListContext | undefined;
    AS(): TerminalNode | undefined;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NamedExpressionSeqContext extends ParserRuleContext {
    namedExpression(): NamedExpressionContext[];
    namedExpression(i: number): NamedExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PartitionFieldListContext extends ParserRuleContext {
    _partitionField: PartitionFieldContext;
    _fields: PartitionFieldContext[];
    partitionField(): PartitionFieldContext[];
    partitionField(i: number): PartitionFieldContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PartitionFieldContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: PartitionFieldContext): void;
}
export declare class PartitionTransformContext extends PartitionFieldContext {
    transform(): TransformContext;
    constructor(ctx: PartitionFieldContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PartitionColumnContext extends PartitionFieldContext {
    colType(): ColTypeContext;
    constructor(ctx: PartitionFieldContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TransformContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: TransformContext): void;
}
export declare class IdentityTransformContext extends TransformContext {
    qualifiedName(): QualifiedNameContext;
    constructor(ctx: TransformContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ApplyTransformContext extends TransformContext {
    _transformName: IdentifierContext;
    _transformArgument: TransformArgumentContext;
    _argument: TransformArgumentContext[];
    identifier(): IdentifierContext;
    transformArgument(): TransformArgumentContext[];
    transformArgument(i: number): TransformArgumentContext;
    constructor(ctx: TransformContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TransformArgumentContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext | undefined;
    constant(): ConstantContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ExpressionContext extends ParserRuleContext {
    booleanExpression(): BooleanExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ExpressionSeqContext extends ParserRuleContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class BooleanExpressionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: BooleanExpressionContext): void;
}
export declare class LogicalNotContext extends BooleanExpressionContext {
    NOT(): TerminalNode;
    booleanExpression(): BooleanExpressionContext;
    constructor(ctx: BooleanExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ExistsContext extends BooleanExpressionContext {
    EXISTS(): TerminalNode;
    query(): QueryContext;
    constructor(ctx: BooleanExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PredicatedContext extends BooleanExpressionContext {
    valueExpression(): ValueExpressionContext;
    predicate(): PredicateContext | undefined;
    constructor(ctx: BooleanExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class LogicalBinaryContext extends BooleanExpressionContext {
    _left: BooleanExpressionContext;
    _operator: Token;
    _right: BooleanExpressionContext;
    booleanExpression(): BooleanExpressionContext[];
    booleanExpression(i: number): BooleanExpressionContext;
    AND(): TerminalNode | undefined;
    OR(): TerminalNode | undefined;
    constructor(ctx: BooleanExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PredicateContext extends ParserRuleContext {
    _kind: Token;
    _lower: ValueExpressionContext;
    _upper: ValueExpressionContext;
    _pattern: ValueExpressionContext;
    _quantifier: Token;
    _escapeChar: Token;
    _right: ValueExpressionContext;
    AND(): TerminalNode | undefined;
    BETWEEN(): TerminalNode | undefined;
    valueExpression(): ValueExpressionContext[];
    valueExpression(i: number): ValueExpressionContext;
    NOT(): TerminalNode | undefined;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    IN(): TerminalNode | undefined;
    query(): QueryContext | undefined;
    RLIKE(): TerminalNode | undefined;
    LIKE(): TerminalNode | undefined;
    ANY(): TerminalNode | undefined;
    SOME(): TerminalNode | undefined;
    ALL(): TerminalNode | undefined;
    ESCAPE(): TerminalNode | undefined;
    STRING(): 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: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ValueExpressionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ValueExpressionContext): void;
}
export declare class ValueExpressionDefaultContext extends ValueExpressionContext {
    primaryExpression(): PrimaryExpressionContext;
    constructor(ctx: ValueExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ArithmeticUnaryContext extends ValueExpressionContext {
    _operator: Token;
    valueExpression(): ValueExpressionContext;
    MINUS(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    TILDE(): TerminalNode | undefined;
    constructor(ctx: ValueExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ArithmeticBinaryContext extends ValueExpressionContext {
    _left: ValueExpressionContext;
    _operator: Token;
    _right: ValueExpressionContext;
    valueExpression(): ValueExpressionContext[];
    valueExpression(i: number): ValueExpressionContext;
    ASTERISK(): TerminalNode | undefined;
    SLASH(): TerminalNode | undefined;
    PERCENT(): TerminalNode | undefined;
    DIV(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    CONCAT_PIPE(): TerminalNode | undefined;
    AMPERSAND(): TerminalNode | undefined;
    HAT(): TerminalNode | undefined;
    PIPE(): TerminalNode | undefined;
    constructor(ctx: ValueExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ComparisonContext extends ValueExpressionContext {
    _left: ValueExpressionContext;
    _right: ValueExpressionContext;
    comparisonOperator(): ComparisonOperatorContext;
    valueExpression(): ValueExpressionContext[];
    valueExpression(i: number): ValueExpressionContext;
    constructor(ctx: ValueExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PrimaryExpressionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: PrimaryExpressionContext): void;
}
export declare class CurrentLikeContext extends PrimaryExpressionContext {
    _name: Token;
    CURRENT_DATE(): TerminalNode | undefined;
    CURRENT_TIMESTAMP(): TerminalNode | undefined;
    CURRENT_USER(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SearchedCaseContext extends PrimaryExpressionContext {
    _elseExpression: ExpressionContext;
    CASE(): TerminalNode;
    END(): TerminalNode;
    whenClause(): WhenClauseContext[];
    whenClause(i: number): WhenClauseContext;
    ELSE(): TerminalNode | undefined;
    expression(): ExpressionContext | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SimpleCaseContext extends PrimaryExpressionContext {
    _value: ExpressionContext;
    _elseExpression: ExpressionContext;
    CASE(): TerminalNode;
    END(): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    whenClause(): WhenClauseContext[];
    whenClause(i: number): WhenClauseContext;
    ELSE(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class CastContext extends PrimaryExpressionContext {
    _name: Token;
    expression(): ExpressionContext;
    AS(): TerminalNode;
    dataType(): DataTypeContext;
    CAST(): TerminalNode | undefined;
    TRY_CAST(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class StructContext extends PrimaryExpressionContext {
    _namedExpression: NamedExpressionContext;
    _argument: NamedExpressionContext[];
    STRUCT(): TerminalNode;
    namedExpression(): NamedExpressionContext[];
    namedExpression(i: number): NamedExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FirstContext extends PrimaryExpressionContext {
    FIRST(): TerminalNode;
    expression(): ExpressionContext;
    IGNORE(): TerminalNode | undefined;
    NULLS(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class LastContext extends PrimaryExpressionContext {
    LAST(): TerminalNode;
    expression(): ExpressionContext;
    IGNORE(): TerminalNode | undefined;
    NULLS(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PositionContext extends PrimaryExpressionContext {
    _substr: ValueExpressionContext;
    _str: ValueExpressionContext;
    POSITION(): TerminalNode;
    IN(): TerminalNode;
    valueExpression(): ValueExpressionContext[];
    valueExpression(i: number): ValueExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ConstantDefaultContext extends PrimaryExpressionContext {
    constant(): ConstantContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class StarContext extends PrimaryExpressionContext {
    ASTERISK(): TerminalNode;
    qualifiedName(): QualifiedNameContext | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RowConstructorContext extends PrimaryExpressionContext {
    namedExpression(): NamedExpressionContext[];
    namedExpression(i: number): NamedExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SubqueryExpressionContext extends PrimaryExpressionContext {
    query(): QueryContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FunctionCallContext extends PrimaryExpressionContext {
    _expression: ExpressionContext;
    _argument: ExpressionContext[];
    _where: BooleanExpressionContext;
    _nullsOption: Token;
    functionName(): FunctionNameContext;
    FILTER(): TerminalNode | undefined;
    WHERE(): TerminalNode | undefined;
    NULLS(): TerminalNode | undefined;
    OVER(): TerminalNode | undefined;
    windowSpec(): WindowSpecContext | undefined;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    booleanExpression(): BooleanExpressionContext | undefined;
    IGNORE(): TerminalNode | undefined;
    RESPECT(): TerminalNode | undefined;
    setQuantifier(): SetQuantifierContext | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class LambdaContext extends PrimaryExpressionContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    expression(): ExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SubscriptContext extends PrimaryExpressionContext {
    _value: PrimaryExpressionContext;
    _index: ValueExpressionContext;
    primaryExpression(): PrimaryExpressionContext;
    valueExpression(): ValueExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ColumnReferenceContext extends PrimaryExpressionContext {
    identifier(): IdentifierContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DereferenceContext extends PrimaryExpressionContext {
    _base: PrimaryExpressionContext;
    _fieldName: IdentifierContext;
    primaryExpression(): PrimaryExpressionContext;
    identifier(): IdentifierContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PostgresCastContext extends PrimaryExpressionContext {
    _value: PrimaryExpressionContext;
    dataType(): DataTypeContext;
    primaryExpression(): PrimaryExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PostgresJsonContext extends PrimaryExpressionContext {
    _value: PrimaryExpressionContext;
    _field: PrimaryExpressionContext;
    primaryExpression(): PrimaryExpressionContext[];
    primaryExpression(i: number): PrimaryExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ParenthesizedExpressionContext extends PrimaryExpressionContext {
    expression(): ExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ExtractContext extends PrimaryExpressionContext {
    _field: IdentifierContext;
    _source: ValueExpressionContext;
    EXTRACT(): TerminalNode;
    FROM(): TerminalNode;
    identifier(): IdentifierContext;
    valueExpression(): ValueExpressionContext;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SubstringContext extends PrimaryExpressionContext {
    _str: ValueExpressionContext;
    _pos: ValueExpressionContext;
    _len: ValueExpressionContext;
    SUBSTR(): TerminalNode | undefined;
    SUBSTRING(): TerminalNode | undefined;
    valueExpression(): ValueExpressionContext[];
    valueExpression(i: number): ValueExpressionContext;
    FROM(): TerminalNode;
    FOR(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TrimContext extends PrimaryExpressionContext {
    _trimOption: Token;
    _trimStr: ValueExpressionContext;
    _srcStr: ValueExpressionContext;
    TRIM(): TerminalNode;
    FROM(): TerminalNode;
    valueExpression(): ValueExpressionContext[];
    valueExpression(i: number): ValueExpressionContext;
    BOTH(): TerminalNode | undefined;
    LEADING(): TerminalNode | undefined;
    TRAILING(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class OverlayContext extends PrimaryExpressionContext {
    _input: ValueExpressionContext;
    _replace: ValueExpressionContext;
    _position: ValueExpressionContext;
    _length: ValueExpressionContext;
    OVERLAY(): TerminalNode;
    PLACING(): TerminalNode;
    FROM(): TerminalNode;
    valueExpression(): ValueExpressionContext[];
    valueExpression(i: number): ValueExpressionContext;
    FOR(): TerminalNode | undefined;
    constructor(ctx: PrimaryExpressionContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ConstantContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ConstantContext): void;
}
export declare class NullLiteralContext extends ConstantContext {
    NULL(): TerminalNode;
    constructor(ctx: ConstantContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IntervalLiteralContext extends ConstantContext {
    interval(): IntervalContext;
    constructor(ctx: ConstantContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TypeConstructorContext extends ConstantContext {
    identifier(): IdentifierContext;
    STRING(): TerminalNode;
    constructor(ctx: ConstantContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NumericLiteralContext extends ConstantContext {
    number(): NumberContext;
    constructor(ctx: ConstantContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class BooleanLiteralContext extends ConstantContext {
    booleanValue(): BooleanValueContext;
    constructor(ctx: ConstantContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class StringLiteralContext extends ConstantContext {
    STRING(): TerminalNode[];
    STRING(i: number): TerminalNode;
    constructor(ctx: ConstantContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ComparisonOperatorContext extends ParserRuleContext {
    EQ(): TerminalNode | undefined;
    NEQ(): TerminalNode | undefined;
    NEQJ(): TerminalNode | undefined;
    LT(): TerminalNode | undefined;
    LTE(): TerminalNode | undefined;
    GT(): TerminalNode | undefined;
    GTE(): TerminalNode | undefined;
    NSEQ(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ArithmeticOperatorContext extends ParserRuleContext {
    PLUS(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    ASTERISK(): TerminalNode | undefined;
    SLASH(): TerminalNode | undefined;
    PERCENT(): TerminalNode | undefined;
    DIV(): TerminalNode | undefined;
    TILDE(): TerminalNode | undefined;
    AMPERSAND(): TerminalNode | undefined;
    PIPE(): TerminalNode | undefined;
    CONCAT_PIPE(): TerminalNode | undefined;
    HAT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PredicateOperatorContext extends ParserRuleContext {
    OR(): TerminalNode | undefined;
    AND(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class BooleanValueContext extends ParserRuleContext {
    TRUE(): TerminalNode | undefined;
    FALSE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IntervalContext extends ParserRuleContext {
    INTERVAL(): TerminalNode;
    errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext | undefined;
    errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ErrorCapturingMultiUnitsIntervalContext extends ParserRuleContext {
    multiUnitsInterval(): MultiUnitsIntervalContext;
    unitToUnitInterval(): UnitToUnitIntervalContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class MultiUnitsIntervalContext extends ParserRuleContext {
    _identifier: IdentifierContext;
    _unit: IdentifierContext[];
    intervalValue(): IntervalValueContext[];
    intervalValue(i: number): IntervalValueContext;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ErrorCapturingUnitToUnitIntervalContext extends ParserRuleContext {
    _body: UnitToUnitIntervalContext;
    _error1: MultiUnitsIntervalContext;
    _error2: UnitToUnitIntervalContext;
    unitToUnitInterval(): UnitToUnitIntervalContext[];
    unitToUnitInterval(i: number): UnitToUnitIntervalContext;
    multiUnitsInterval(): MultiUnitsIntervalContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class UnitToUnitIntervalContext extends ParserRuleContext {
    _value: IntervalValueContext;
    _from: IdentifierContext;
    _to: IdentifierContext;
    TO(): TerminalNode;
    intervalValue(): IntervalValueContext;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IntervalValueContext extends ParserRuleContext {
    INTEGER_VALUE(): TerminalNode | undefined;
    DECIMAL_VALUE(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ColPositionContext extends ParserRuleContext {
    _position: Token;
    _afterCol: ErrorCapturingIdentifierContext;
    FIRST(): TerminalNode | undefined;
    AFTER(): TerminalNode | undefined;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DataTypeContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: DataTypeContext): void;
}
export declare class ComplexDataTypeContext extends DataTypeContext {
    _complex: Token;
    LT(): TerminalNode | undefined;
    dataType(): DataTypeContext[];
    dataType(i: number): DataTypeContext;
    GT(): TerminalNode | undefined;
    ARRAY(): TerminalNode | undefined;
    MAP(): TerminalNode | undefined;
    STRUCT(): TerminalNode | undefined;
    NEQ(): TerminalNode | undefined;
    complexColTypeList(): ComplexColTypeListContext | undefined;
    constructor(ctx: DataTypeContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class YearMonthIntervalDataTypeContext extends DataTypeContext {
    _from: Token;
    _to: Token;
    INTERVAL(): TerminalNode;
    YEAR(): TerminalNode | undefined;
    MONTH(): TerminalNode[];
    MONTH(i: number): TerminalNode;
    TO(): TerminalNode | undefined;
    constructor(ctx: DataTypeContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DayTimeIntervalDataTypeContext extends DataTypeContext {
    _from: Token;
    _to: Token;
    INTERVAL(): TerminalNode;
    DAY(): TerminalNode | undefined;
    HOUR(): TerminalNode[];
    HOUR(i: number): TerminalNode;
    MINUTE(): TerminalNode[];
    MINUTE(i: number): TerminalNode;
    SECOND(): TerminalNode[];
    SECOND(i: number): TerminalNode;
    TO(): TerminalNode | undefined;
    constructor(ctx: DataTypeContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class PrimitiveDataTypeContext extends DataTypeContext {
    identifier(): IdentifierContext;
    INTEGER_VALUE(): TerminalNode[];
    INTEGER_VALUE(i: number): TerminalNode;
    constructor(ctx: DataTypeContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QualifiedColTypeWithPositionListContext extends ParserRuleContext {
    qualifiedColTypeWithPosition(): QualifiedColTypeWithPositionContext[];
    qualifiedColTypeWithPosition(i: number): QualifiedColTypeWithPositionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QualifiedColTypeWithPositionContext extends ParserRuleContext {
    _name: MultipartIdentifierContext;
    dataType(): DataTypeContext;
    multipartIdentifier(): MultipartIdentifierContext;
    NOT(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    commentSpec(): CommentSpecContext | undefined;
    colPosition(): ColPositionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ColTypeListContext extends ParserRuleContext {
    colType(): ColTypeContext[];
    colType(i: number): ColTypeContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ColTypeContext extends ParserRuleContext {
    _colName: ErrorCapturingIdentifierContext;
    dataType(): DataTypeContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext;
    NOT(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    commentSpec(): CommentSpecContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ComplexColTypeListContext extends ParserRuleContext {
    complexColType(): ComplexColTypeContext[];
    complexColType(i: number): ComplexColTypeContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ComplexColTypeContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    dataType(): DataTypeContext;
    NOT(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    commentSpec(): CommentSpecContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class WhenClauseContext extends ParserRuleContext {
    _condition: ExpressionContext;
    _result: ExpressionContext;
    WHEN(): TerminalNode;
    THEN(): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class WindowClauseContext extends ParserRuleContext {
    WINDOW(): TerminalNode;
    namedWindow(): NamedWindowContext[];
    namedWindow(i: number): NamedWindowContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NamedWindowContext extends ParserRuleContext {
    _name: ErrorCapturingIdentifierContext;
    AS(): TerminalNode;
    windowSpec(): WindowSpecContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class WindowSpecContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: WindowSpecContext): void;
}
export declare class WindowRefContext extends WindowSpecContext {
    _name: ErrorCapturingIdentifierContext;
    errorCapturingIdentifier(): ErrorCapturingIdentifierContext;
    constructor(ctx: WindowSpecContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class WindowDefContext extends WindowSpecContext {
    _expression: ExpressionContext;
    _partition: ExpressionContext[];
    CLUSTER(): TerminalNode | undefined;
    BY(): TerminalNode[];
    BY(i: number): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    windowFrame(): WindowFrameContext | undefined;
    sortItem(): SortItemContext[];
    sortItem(i: number): SortItemContext;
    PARTITION(): TerminalNode | undefined;
    DISTRIBUTE(): TerminalNode | undefined;
    ORDER(): TerminalNode | undefined;
    SORT(): TerminalNode | undefined;
    constructor(ctx: WindowSpecContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class WindowFrameContext extends ParserRuleContext {
    _frameType: Token;
    _startBound: FrameBoundContext;
    _endBound: FrameBoundContext;
    RANGE(): TerminalNode | undefined;
    frameBound(): FrameBoundContext[];
    frameBound(i: number): FrameBoundContext;
    ROWS(): TerminalNode | undefined;
    BETWEEN(): TerminalNode | undefined;
    AND(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FrameBoundContext extends ParserRuleContext {
    _boundType: Token;
    UNBOUNDED(): TerminalNode | undefined;
    PRECEDING(): TerminalNode | undefined;
    FOLLOWING(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    CURRENT(): TerminalNode | undefined;
    expression(): ExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QualifiedNameListContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext[];
    qualifiedName(i: number): QualifiedNameContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FunctionNameContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext | undefined;
    FILTER(): TerminalNode | undefined;
    LEFT(): TerminalNode | undefined;
    RIGHT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QualifiedNameContext extends ParserRuleContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ErrorCapturingIdentifierContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class ErrorCapturingIdentifierExtraContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ErrorCapturingIdentifierExtraContext): void;
}
export declare class ErrorIdentContext extends ErrorCapturingIdentifierExtraContext {
    MINUS(): TerminalNode[];
    MINUS(i: number): TerminalNode;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    constructor(ctx: ErrorCapturingIdentifierExtraContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class RealIdentContext extends ErrorCapturingIdentifierExtraContext {
    constructor(ctx: ErrorCapturingIdentifierExtraContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IdentifierContext extends ParserRuleContext {
    strictIdentifier(): StrictIdentifierContext | undefined;
    strictNonReserved(): StrictNonReservedContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class StrictIdentifierContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: StrictIdentifierContext): void;
}
export declare class UnquotedIdentifierContext extends StrictIdentifierContext {
    IDENTIFIER(): TerminalNode | undefined;
    ansiNonReserved(): AnsiNonReservedContext | undefined;
    nonReserved(): NonReservedContext | undefined;
    constructor(ctx: StrictIdentifierContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QuotedIdentifierAlternativeContext extends StrictIdentifierContext {
    quotedIdentifier(): QuotedIdentifierContext;
    constructor(ctx: StrictIdentifierContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class QuotedIdentifierContext extends ParserRuleContext {
    BACKQUOTED_IDENTIFIER(): TerminalNode | undefined;
    DOUBLEQUOTED_IDENTIFIER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NumberContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: NumberContext): void;
}
export declare class ExponentLiteralContext extends NumberContext {
    EXPONENT_VALUE(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DecimalLiteralContext extends NumberContext {
    DECIMAL_VALUE(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class LegacyDecimalLiteralContext extends NumberContext {
    EXPONENT_VALUE(): TerminalNode | undefined;
    DECIMAL_VALUE(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class IntegerLiteralContext extends NumberContext {
    INTEGER_VALUE(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class BigIntLiteralContext extends NumberContext {
    BIGINT_LITERAL(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class SmallIntLiteralContext extends NumberContext {
    SMALLINT_LITERAL(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class TinyIntLiteralContext extends NumberContext {
    TINYINT_LITERAL(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class DoubleLiteralContext extends NumberContext {
    DOUBLE_LITERAL(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class FloatLiteralContext extends NumberContext {
    FLOAT_LITERAL(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class BigDecimalLiteralContext extends NumberContext {
    BIGDECIMAL_LITERAL(): TerminalNode;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: NumberContext);
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AlterColumnActionContext extends ParserRuleContext {
    _setOrDrop: Token;
    TYPE(): TerminalNode | undefined;
    dataType(): DataTypeContext | undefined;
    commentSpec(): CommentSpecContext | undefined;
    colPosition(): ColPositionContext | undefined;
    NOT(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    DROP(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class AnsiNonReservedContext extends ParserRuleContext {
    ADD(): TerminalNode | undefined;
    AFTER(): TerminalNode | undefined;
    ALTER(): TerminalNode | undefined;
    ANALYZE(): TerminalNode | undefined;
    ANTI(): TerminalNode | undefined;
    ARCHIVE(): TerminalNode | undefined;
    ARRAY(): TerminalNode | undefined;
    ASC(): TerminalNode | undefined;
    AT(): TerminalNode | undefined;
    BETWEEN(): TerminalNode | undefined;
    BUCKET(): TerminalNode | undefined;
    BUCKETS(): TerminalNode | undefined;
    BY(): TerminalNode | undefined;
    CACHE(): TerminalNode | undefined;
    CASCADE(): TerminalNode | undefined;
    CHANGE(): TerminalNode | undefined;
    CLEAR(): TerminalNode | undefined;
    CLUSTER(): TerminalNode | undefined;
    CLUSTERED(): TerminalNode | undefined;
    CODEGEN(): TerminalNode | undefined;
    COLLECTION(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    COMMENT(): TerminalNode | undefined;
    COMMIT(): TerminalNode | undefined;
    COMPACT(): TerminalNode | undefined;
    COMPACTIONS(): TerminalNode | undefined;
    COMPUTE(): TerminalNode | undefined;
    CONCATENATE(): TerminalNode | undefined;
    COST(): TerminalNode | undefined;
    CUBE(): TerminalNode | undefined;
    CURRENT(): TerminalNode | undefined;
    DATA(): TerminalNode | undefined;
    DATABASE(): TerminalNode | undefined;
    DATABASES(): TerminalNode | undefined;
    DAY(): TerminalNode | undefined;
    DBPROPERTIES(): TerminalNode | undefined;
    DEFINED(): TerminalNode | undefined;
    DELETE(): TerminalNode | undefined;
    DELIMITED(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    DESCRIBE(): TerminalNode | undefined;
    DFS(): TerminalNode | undefined;
    DIRECTORIES(): TerminalNode | undefined;
    DIRECTORY(): TerminalNode | undefined;
    DISTRIBUTE(): TerminalNode | undefined;
    DIV(): TerminalNode | undefined;
    DROP(): TerminalNode | undefined;
    ESCAPED(): TerminalNode | undefined;
    EXCHANGE(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    EXPLAIN(): TerminalNode | undefined;
    EXPORT(): TerminalNode | undefined;
    EXTENDED(): TerminalNode | undefined;
    EXTERNAL(): TerminalNode | undefined;
    EXTRACT(): TerminalNode | undefined;
    FIELDS(): TerminalNode | undefined;
    FILEFORMAT(): TerminalNode | undefined;
    FIRST(): TerminalNode | undefined;
    FOLLOWING(): TerminalNode | undefined;
    FORMAT(): TerminalNode | undefined;
    FORMATTED(): TerminalNode | undefined;
    FUNCTION(): TerminalNode | undefined;
    FUNCTIONS(): TerminalNode | undefined;
    GLOBAL(): TerminalNode | undefined;
    GROUPING(): TerminalNode | undefined;
    HOUR(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    IGNORE(): TerminalNode | undefined;
    IMPORT(): TerminalNode | undefined;
    INDEX(): TerminalNode | undefined;
    INDEXES(): TerminalNode | undefined;
    INPATH(): TerminalNode | undefined;
    INPUTFORMAT(): TerminalNode | undefined;
    INSERT(): TerminalNode | undefined;
    INTERVAL(): TerminalNode | undefined;
    ITEMS(): TerminalNode | undefined;
    KEYS(): TerminalNode | undefined;
    LAST(): TerminalNode | undefined;
    LAZY(): TerminalNode | undefined;
    LIKE(): TerminalNode | undefined;
    LIMIT(): TerminalNode | undefined;
    LINES(): TerminalNode | undefined;
    LIST(): TerminalNode | undefined;
    LOAD(): TerminalNode | undefined;
    LOCAL(): TerminalNode | undefined;
    LOCATION(): TerminalNode | undefined;
    LOCK(): TerminalNode | undefined;
    LOCKS(): TerminalNode | undefined;
    LOGICAL(): TerminalNode | undefined;
    MACRO(): TerminalNode | undefined;
    MAP(): TerminalNode | undefined;
    MATCHED(): TerminalNode | undefined;
    MERGE(): TerminalNode | undefined;
    MINUTE(): TerminalNode | undefined;
    MONTH(): TerminalNode | undefined;
    MSCK(): TerminalNode | undefined;
    NAMESPACE(): TerminalNode | undefined;
    NAMESPACES(): TerminalNode | undefined;
    NO(): TerminalNode | undefined;
    NULLS(): TerminalNode | undefined;
    OF(): TerminalNode | undefined;
    OPTION(): TerminalNode | undefined;
    OPTIONS(): TerminalNode | undefined;
    OUT(): TerminalNode | undefined;
    OUTPUTFORMAT(): TerminalNode | undefined;
    OVER(): TerminalNode | undefined;
    OVERLAY(): TerminalNode | undefined;
    OVERWRITE(): TerminalNode | undefined;
    PARTITION(): TerminalNode | undefined;
    PARTITIONED(): TerminalNode | undefined;
    PARTITIONS(): TerminalNode | undefined;
    PERCENTLIT(): TerminalNode | undefined;
    PIVOT(): TerminalNode | undefined;
    PLACING(): TerminalNode | undefined;
    POSITION(): TerminalNode | undefined;
    PRECEDING(): TerminalNode | undefined;
    PRINCIPALS(): TerminalNode | undefined;
    PROPERTIES(): TerminalNode | undefined;
    PURGE(): TerminalNode | undefined;
    QUERY(): TerminalNode | undefined;
    RANGE(): TerminalNode | undefined;
    RECORDREADER(): TerminalNode | undefined;
    RECORDWRITER(): TerminalNode | undefined;
    RECOVER(): TerminalNode | undefined;
    REDUCE(): TerminalNode | undefined;
    REFRESH(): TerminalNode | undefined;
    RENAME(): TerminalNode | undefined;
    REPAIR(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    RESET(): TerminalNode | undefined;
    RESPECT(): TerminalNode | undefined;
    RESTRICT(): TerminalNode | undefined;
    REVOKE(): TerminalNode | undefined;
    RLIKE(): TerminalNode | undefined;
    ROLE(): TerminalNode | undefined;
    ROLES(): TerminalNode | undefined;
    ROLLBACK(): TerminalNode | undefined;
    ROLLUP(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    ROWS(): TerminalNode | undefined;
    SCHEMA(): TerminalNode | undefined;
    SECOND(): TerminalNode | undefined;
    SEMI(): TerminalNode | undefined;
    SEPARATED(): TerminalNode | undefined;
    SERDE(): TerminalNode | undefined;
    SERDEPROPERTIES(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    SETMINUS(): TerminalNode | undefined;
    SETS(): TerminalNode | undefined;
    SHOW(): TerminalNode | undefined;
    SKEWED(): TerminalNode | undefined;
    SORT(): TerminalNode | undefined;
    SORTED(): TerminalNode | undefined;
    START(): TerminalNode | undefined;
    STATISTICS(): TerminalNode | undefined;
    STORED(): TerminalNode | undefined;
    STRATIFY(): TerminalNode | undefined;
    STRUCT(): TerminalNode | undefined;
    SUBSTR(): TerminalNode | undefined;
    SUBSTRING(): TerminalNode | undefined;
    SYNC(): TerminalNode | undefined;
    TABLES(): TerminalNode | undefined;
    TABLESAMPLE(): TerminalNode | undefined;
    TBLPROPERTIES(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    TERMINATED(): TerminalNode | undefined;
    TOUCH(): TerminalNode | undefined;
    TRANSACTION(): TerminalNode | undefined;
    TRANSACTIONS(): TerminalNode | undefined;
    TRANSFORM(): TerminalNode | undefined;
    TRIM(): TerminalNode | undefined;
    TRUE(): TerminalNode | undefined;
    TRUNCATE(): TerminalNode | undefined;
    TRY_CAST(): TerminalNode | undefined;
    TYPE(): TerminalNode | undefined;
    UNARCHIVE(): TerminalNode | undefined;
    UNBOUNDED(): TerminalNode | undefined;
    UNCACHE(): TerminalNode | undefined;
    UNLOCK(): TerminalNode | undefined;
    UNSET(): TerminalNode | undefined;
    UPDATE(): TerminalNode | undefined;
    USE(): TerminalNode | undefined;
    VALUES(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    VIEWS(): TerminalNode | undefined;
    WINDOW(): TerminalNode | undefined;
    YEAR(): TerminalNode | undefined;
    ZONE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class StrictNonReservedContext extends ParserRuleContext {
    ANTI(): TerminalNode | undefined;
    CROSS(): TerminalNode | undefined;
    EXCEPT(): TerminalNode | undefined;
    FULL(): TerminalNode | undefined;
    INNER(): TerminalNode | undefined;
    INTERSECT(): TerminalNode | undefined;
    JOIN(): TerminalNode | undefined;
    LATERAL(): TerminalNode | undefined;
    LEFT(): TerminalNode | undefined;
    NATURAL(): TerminalNode | undefined;
    ON(): TerminalNode | undefined;
    RIGHT(): TerminalNode | undefined;
    SEMI(): TerminalNode | undefined;
    SETMINUS(): TerminalNode | undefined;
    UNION(): TerminalNode | undefined;
    USING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
export declare class NonReservedContext extends ParserRuleContext {
    ADD(): TerminalNode | undefined;
    AFTER(): TerminalNode | undefined;
    ALL(): TerminalNode | undefined;
    ALTER(): TerminalNode | undefined;
    ANALYZE(): TerminalNode | undefined;
    AND(): TerminalNode | undefined;
    ANY(): TerminalNode | undefined;
    ARCHIVE(): TerminalNode | undefined;
    ARRAY(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    ASC(): TerminalNode | undefined;
    AT(): TerminalNode | undefined;
    AUTHORIZATION(): TerminalNode | undefined;
    BETWEEN(): TerminalNode | undefined;
    BOTH(): TerminalNode | undefined;
    BUCKET(): TerminalNode | undefined;
    BUCKETS(): TerminalNode | undefined;
    BY(): TerminalNode | undefined;
    CACHE(): TerminalNode | undefined;
    CASCADE(): TerminalNode | undefined;
    CASE(): TerminalNode | undefined;
    CAST(): TerminalNode | undefined;
    CHANGE(): TerminalNode | undefined;
    CHECK(): TerminalNode | undefined;
    CLEAR(): TerminalNode | undefined;
    CLUSTER(): TerminalNode | undefined;
    CLUSTERED(): TerminalNode | undefined;
    CODEGEN(): TerminalNode | undefined;
    COLLATE(): TerminalNode | undefined;
    COLLECTION(): TerminalNode | undefined;
    COLUMN(): TerminalNode | undefined;
    COLUMNS(): TerminalNode | undefined;
    COMMENT(): TerminalNode | undefined;
    COMMIT(): TerminalNode | undefined;
    COMPACT(): TerminalNode | undefined;
    COMPACTIONS(): TerminalNode | undefined;
    COMPUTE(): TerminalNode | undefined;
    CONCATENATE(): TerminalNode | undefined;
    CONSTRAINT(): TerminalNode | undefined;
    COST(): TerminalNode | undefined;
    CREATE(): TerminalNode | undefined;
    CUBE(): TerminalNode | undefined;
    CURRENT(): TerminalNode | undefined;
    CURRENT_DATE(): TerminalNode | undefined;
    CURRENT_TIME(): TerminalNode | undefined;
    CURRENT_TIMESTAMP(): TerminalNode | undefined;
    CURRENT_USER(): TerminalNode | undefined;
    DATA(): TerminalNode | undefined;
    DATABASE(): TerminalNode | undefined;
    DATABASES(): TerminalNode | undefined;
    DAY(): TerminalNode | undefined;
    DBPROPERTIES(): TerminalNode | undefined;
    DEFINED(): TerminalNode | undefined;
    DELETE(): TerminalNode | undefined;
    DELIMITED(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    DESCRIBE(): TerminalNode | undefined;
    DFS(): TerminalNode | undefined;
    DIRECTORIES(): TerminalNode | undefined;
    DIRECTORY(): TerminalNode | undefined;
    DISTINCT(): TerminalNode | undefined;
    DISTRIBUTE(): TerminalNode | undefined;
    DIV(): TerminalNode | undefined;
    DROP(): TerminalNode | undefined;
    ELSE(): TerminalNode | undefined;
    END(): TerminalNode | undefined;
    ESCAPE(): TerminalNode | undefined;
    ESCAPED(): TerminalNode | undefined;
    EXCHANGE(): TerminalNode | undefined;
    EXISTS(): TerminalNode | undefined;
    EXPLAIN(): TerminalNode | undefined;
    EXPORT(): TerminalNode | undefined;
    EXTENDED(): TerminalNode | undefined;
    EXTERNAL(): TerminalNode | undefined;
    EXTRACT(): TerminalNode | undefined;
    FALSE(): TerminalNode | undefined;
    FETCH(): TerminalNode | undefined;
    FILTER(): TerminalNode | undefined;
    FIELDS(): TerminalNode | undefined;
    FILEFORMAT(): TerminalNode | undefined;
    FIRST(): TerminalNode | undefined;
    FOLLOWING(): TerminalNode | undefined;
    FOR(): TerminalNode | undefined;
    FOREIGN(): TerminalNode | undefined;
    FORMAT(): TerminalNode | undefined;
    FORMATTED(): TerminalNode | undefined;
    FROM(): TerminalNode | undefined;
    FUNCTION(): TerminalNode | undefined;
    FUNCTIONS(): TerminalNode | undefined;
    GLOBAL(): TerminalNode | undefined;
    GRANT(): TerminalNode | undefined;
    GROUP(): TerminalNode | undefined;
    GROUPING(): TerminalNode | undefined;
    HAVING(): TerminalNode | undefined;
    HOUR(): TerminalNode | undefined;
    IF(): TerminalNode | undefined;
    IGNORE(): TerminalNode | undefined;
    IMPORT(): TerminalNode | undefined;
    IN(): TerminalNode | undefined;
    INDEX(): TerminalNode | undefined;
    INDEXES(): TerminalNode | undefined;
    INPATH(): TerminalNode | undefined;
    INPUTFORMAT(): TerminalNode | undefined;
    INSERT(): TerminalNode | undefined;
    INTERVAL(): TerminalNode | undefined;
    INTO(): TerminalNode | undefined;
    IS(): TerminalNode | undefined;
    ITEMS(): TerminalNode | undefined;
    KEYS(): TerminalNode | undefined;
    LAST(): TerminalNode | undefined;
    LAZY(): TerminalNode | undefined;
    LEADING(): TerminalNode | undefined;
    LIKE(): TerminalNode | undefined;
    LIMIT(): TerminalNode | undefined;
    LINES(): TerminalNode | undefined;
    LIST(): TerminalNode | undefined;
    LOAD(): TerminalNode | undefined;
    LOCAL(): TerminalNode | undefined;
    LOCATION(): TerminalNode | undefined;
    LOCK(): TerminalNode | undefined;
    LOCKS(): TerminalNode | undefined;
    LOGICAL(): TerminalNode | undefined;
    MACRO(): TerminalNode | undefined;
    MAP(): TerminalNode | undefined;
    MATCHED(): TerminalNode | undefined;
    MERGE(): TerminalNode | undefined;
    MINUTE(): TerminalNode | undefined;
    MONTH(): TerminalNode | undefined;
    MSCK(): TerminalNode | undefined;
    NAMESPACE(): TerminalNode | undefined;
    NAMESPACES(): TerminalNode | undefined;
    NO(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    NULLS(): TerminalNode | undefined;
    OF(): TerminalNode | undefined;
    ONLY(): TerminalNode | undefined;
    OPTION(): TerminalNode | undefined;
    OPTIONS(): TerminalNode | undefined;
    OR(): TerminalNode | undefined;
    ORDER(): TerminalNode | undefined;
    OUT(): TerminalNode | undefined;
    OUTER(): TerminalNode | undefined;
    OUTPUTFORMAT(): TerminalNode | undefined;
    OVER(): TerminalNode | undefined;
    OVERLAPS(): TerminalNode | undefined;
    OVERLAY(): TerminalNode | undefined;
    OVERWRITE(): TerminalNode | undefined;
    PARTITION(): TerminalNode | undefined;
    PARTITIONED(): TerminalNode | undefined;
    PARTITIONS(): TerminalNode | undefined;
    PERCENTLIT(): TerminalNode | undefined;
    PIVOT(): TerminalNode | undefined;
    PLACING(): TerminalNode | undefined;
    POSITION(): TerminalNode | undefined;
    PRECEDING(): TerminalNode | undefined;
    PRIMARY(): TerminalNode | undefined;
    PRINCIPALS(): TerminalNode | undefined;
    PROPERTIES(): TerminalNode | undefined;
    PURGE(): TerminalNode | undefined;
    QUERY(): TerminalNode | undefined;
    RANGE(): TerminalNode | undefined;
    RECORDREADER(): TerminalNode | undefined;
    RECORDWRITER(): TerminalNode | undefined;
    RECOVER(): TerminalNode | undefined;
    REDUCE(): TerminalNode | undefined;
    REFERENCES(): TerminalNode | undefined;
    REFRESH(): TerminalNode | undefined;
    RENAME(): TerminalNode | undefined;
    REPAIR(): TerminalNode | undefined;
    REPLACE(): TerminalNode | undefined;
    RESET(): TerminalNode | undefined;
    RESPECT(): TerminalNode | undefined;
    RESTRICT(): TerminalNode | undefined;
    REVOKE(): TerminalNode | undefined;
    RLIKE(): TerminalNode | undefined;
    ROLE(): TerminalNode | undefined;
    ROLES(): TerminalNode | undefined;
    ROLLBACK(): TerminalNode | undefined;
    ROLLUP(): TerminalNode | undefined;
    ROW(): TerminalNode | undefined;
    ROWS(): TerminalNode | undefined;
    SCHEMA(): TerminalNode | undefined;
    SECOND(): TerminalNode | undefined;
    SELECT(): TerminalNode | undefined;
    SEPARATED(): TerminalNode | undefined;
    SERDE(): TerminalNode | undefined;
    SERDEPROPERTIES(): TerminalNode | undefined;
    SESSION_USER(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    SETS(): TerminalNode | undefined;
    SHOW(): TerminalNode | undefined;
    SKEWED(): TerminalNode | undefined;
    SOME(): TerminalNode | undefined;
    SORT(): TerminalNode | undefined;
    SORTED(): TerminalNode | undefined;
    START(): TerminalNode | undefined;
    STATISTICS(): TerminalNode | undefined;
    STORED(): TerminalNode | undefined;
    STRATIFY(): TerminalNode | undefined;
    STRUCT(): TerminalNode | undefined;
    SUBSTR(): TerminalNode | undefined;
    SUBSTRING(): TerminalNode | undefined;
    SYNC(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    TABLES(): TerminalNode | undefined;
    TABLESAMPLE(): TerminalNode | undefined;
    TBLPROPERTIES(): TerminalNode | undefined;
    TEMPORARY(): TerminalNode | undefined;
    TERMINATED(): TerminalNode | undefined;
    THEN(): TerminalNode | undefined;
    TIME(): TerminalNode | undefined;
    TO(): TerminalNode | undefined;
    TOUCH(): TerminalNode | undefined;
    TRAILING(): TerminalNode | undefined;
    TRANSACTION(): TerminalNode | undefined;
    TRANSACTIONS(): TerminalNode | undefined;
    TRANSFORM(): TerminalNode | undefined;
    TRIM(): TerminalNode | undefined;
    TRUE(): TerminalNode | undefined;
    TRUNCATE(): TerminalNode | undefined;
    TRY_CAST(): TerminalNode | undefined;
    TYPE(): TerminalNode | undefined;
    UNARCHIVE(): TerminalNode | undefined;
    UNBOUNDED(): TerminalNode | undefined;
    UNCACHE(): TerminalNode | undefined;
    UNIQUE(): TerminalNode | undefined;
    UNKNOWN(): TerminalNode | undefined;
    UNLOCK(): TerminalNode | undefined;
    UNSET(): TerminalNode | undefined;
    UPDATE(): TerminalNode | undefined;
    USE(): TerminalNode | undefined;
    USER(): TerminalNode | undefined;
    VALUES(): TerminalNode | undefined;
    VIEW(): TerminalNode | undefined;
    VIEWS(): TerminalNode | undefined;
    WHEN(): TerminalNode | undefined;
    WHERE(): TerminalNode | undefined;
    WINDOW(): TerminalNode | undefined;
    WITH(): TerminalNode | undefined;
    YEAR(): TerminalNode | undefined;
    ZONE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: SqlBaseListener): void;
    exitRule(listener: SqlBaseListener): void;
    accept<Result>(visitor: SqlBaseVisitor<Result>): Result;
}
//# sourceMappingURL=SqlBaseParser.d.ts.map