@elastic/esql 0.0.1

package/lib/parser/antlr/esql_parser.d.ts

@@ -0,0 +1,1847 @@
+import { ATN, DFA, FailedPredicateException, RuleContext, ParserRuleContext, TerminalNode, Token, TokenStream } from 'antlr4';
+import esql_parserListener from "./esql_parserListener.js";
+import parser_config from './parser_config.js';
+export default class esql_parser extends parser_config {
+    static readonly LINE_COMMENT = 1;
+    static readonly MULTILINE_COMMENT = 2;
+    static readonly WS = 3;
+    static readonly CHANGE_POINT = 4;
+    static readonly ENRICH = 5;
+    static readonly DEV_EXPLAIN = 6;
+    static readonly COMPLETION = 7;
+    static readonly DISSECT = 8;
+    static readonly EVAL = 9;
+    static readonly GROK = 10;
+    static readonly LIMIT = 11;
+    static readonly RERANK = 12;
+    static readonly ROW = 13;
+    static readonly SAMPLE = 14;
+    static readonly SORT = 15;
+    static readonly STATS = 16;
+    static readonly WHERE = 17;
+    static readonly URI_PARTS = 18;
+    static readonly METRICS_INFO = 19;
+    static readonly FROM = 20;
+    static readonly TS = 21;
+    static readonly EXTERNAL = 22;
+    static readonly FORK = 23;
+    static readonly FUSE = 24;
+    static readonly INLINE = 25;
+    static readonly INLINESTATS = 26;
+    static readonly JOIN_LOOKUP = 27;
+    static readonly DEV_JOIN_FULL = 28;
+    static readonly DEV_JOIN_LEFT = 29;
+    static readonly DEV_JOIN_RIGHT = 30;
+    static readonly DEV_LOOKUP = 31;
+    static readonly DEV_MMR = 32;
+    static readonly MV_EXPAND = 33;
+    static readonly DROP = 34;
+    static readonly KEEP = 35;
+    static readonly DEV_INSIST = 36;
+    static readonly PROMQL = 37;
+    static readonly RENAME = 38;
+    static readonly SET = 39;
+    static readonly SHOW = 40;
+    static readonly UNKNOWN_CMD = 41;
+    static readonly CHANGE_POINT_LINE_COMMENT = 42;
+    static readonly CHANGE_POINT_MULTILINE_COMMENT = 43;
+    static readonly CHANGE_POINT_WS = 44;
+    static readonly ENRICH_POLICY_NAME = 45;
+    static readonly ENRICH_LINE_COMMENT = 46;
+    static readonly ENRICH_MULTILINE_COMMENT = 47;
+    static readonly ENRICH_WS = 48;
+    static readonly ENRICH_FIELD_LINE_COMMENT = 49;
+    static readonly ENRICH_FIELD_MULTILINE_COMMENT = 50;
+    static readonly ENRICH_FIELD_WS = 51;
+    static readonly EXPLAIN_WS = 52;
+    static readonly EXPLAIN_LINE_COMMENT = 53;
+    static readonly EXPLAIN_MULTILINE_COMMENT = 54;
+    static readonly PIPE = 55;
+    static readonly QUOTED_STRING = 56;
+    static readonly INTEGER_LITERAL = 57;
+    static readonly DECIMAL_LITERAL = 58;
+    static readonly AND = 59;
+    static readonly ASC = 60;
+    static readonly ASSIGN = 61;
+    static readonly BY = 62;
+    static readonly CAST_OP = 63;
+    static readonly COLON = 64;
+    static readonly SEMICOLON = 65;
+    static readonly COMMA = 66;
+    static readonly DESC = 67;
+    static readonly DOT = 68;
+    static readonly FALSE = 69;
+    static readonly FIRST = 70;
+    static readonly IN = 71;
+    static readonly IS = 72;
+    static readonly LAST = 73;
+    static readonly LIKE = 74;
+    static readonly NOT = 75;
+    static readonly NULL = 76;
+    static readonly NULLS = 77;
+    static readonly ON = 78;
+    static readonly OR = 79;
+    static readonly PARAM = 80;
+    static readonly RLIKE = 81;
+    static readonly TRUE = 82;
+    static readonly WITH = 83;
+    static readonly EQ = 84;
+    static readonly CIEQ = 85;
+    static readonly NEQ = 86;
+    static readonly LT = 87;
+    static readonly LTE = 88;
+    static readonly GT = 89;
+    static readonly GTE = 90;
+    static readonly PLUS = 91;
+    static readonly MINUS = 92;
+    static readonly ASTERISK = 93;
+    static readonly SLASH = 94;
+    static readonly PERCENT = 95;
+    static readonly LEFT_BRACES = 96;
+    static readonly RIGHT_BRACES = 97;
+    static readonly DOUBLE_PARAMS = 98;
+    static readonly NAMED_OR_POSITIONAL_PARAM = 99;
+    static readonly NAMED_OR_POSITIONAL_DOUBLE_PARAMS = 100;
+    static readonly OPENING_BRACKET = 101;
+    static readonly CLOSING_BRACKET = 102;
+    static readonly LP = 103;
+    static readonly RP = 104;
+    static readonly UNQUOTED_IDENTIFIER = 105;
+    static readonly QUOTED_IDENTIFIER = 106;
+    static readonly EXPR_LINE_COMMENT = 107;
+    static readonly EXPR_MULTILINE_COMMENT = 108;
+    static readonly EXPR_WS = 109;
+    static readonly METADATA = 110;
+    static readonly UNQUOTED_SOURCE = 111;
+    static readonly FROM_LINE_COMMENT = 112;
+    static readonly FROM_MULTILINE_COMMENT = 113;
+    static readonly FROM_WS = 114;
+    static readonly FORK_WS = 115;
+    static readonly FORK_LINE_COMMENT = 116;
+    static readonly FORK_MULTILINE_COMMENT = 117;
+    static readonly GROUP = 118;
+    static readonly SCORE = 119;
+    static readonly KEY = 120;
+    static readonly FUSE_LINE_COMMENT = 121;
+    static readonly FUSE_MULTILINE_COMMENT = 122;
+    static readonly FUSE_WS = 123;
+    static readonly INLINE_STATS = 124;
+    static readonly INLINE_LINE_COMMENT = 125;
+    static readonly INLINE_MULTILINE_COMMENT = 126;
+    static readonly INLINE_WS = 127;
+    static readonly JOIN = 128;
+    static readonly USING = 129;
+    static readonly JOIN_LINE_COMMENT = 130;
+    static readonly JOIN_MULTILINE_COMMENT = 131;
+    static readonly JOIN_WS = 132;
+    static readonly LOOKUP_LINE_COMMENT = 133;
+    static readonly LOOKUP_MULTILINE_COMMENT = 134;
+    static readonly LOOKUP_WS = 135;
+    static readonly LOOKUP_FIELD_LINE_COMMENT = 136;
+    static readonly LOOKUP_FIELD_MULTILINE_COMMENT = 137;
+    static readonly LOOKUP_FIELD_WS = 138;
+    static readonly MMR_LIMIT = 139;
+    static readonly MMR_LINE_COMMENT = 140;
+    static readonly MMR_MULTILINE_COMMENT = 141;
+    static readonly MMR_WS = 142;
+    static readonly MVEXPAND_LINE_COMMENT = 143;
+    static readonly MVEXPAND_MULTILINE_COMMENT = 144;
+    static readonly MVEXPAND_WS = 145;
+    static readonly ID_PATTERN = 146;
+    static readonly PROJECT_LINE_COMMENT = 147;
+    static readonly PROJECT_MULTILINE_COMMENT = 148;
+    static readonly PROJECT_WS = 149;
+    static readonly PROMQL_PARAMS_LINE_COMMENT = 150;
+    static readonly PROMQL_PARAMS_MULTILINE_COMMENT = 151;
+    static readonly PROMQL_PARAMS_WS = 152;
+    static readonly PROMQL_QUERY_COMMENT = 153;
+    static readonly PROMQL_SINGLE_QUOTED_STRING = 154;
+    static readonly PROMQL_OTHER_QUERY_CONTENT = 155;
+    static readonly AS = 156;
+    static readonly RENAME_LINE_COMMENT = 157;
+    static readonly RENAME_MULTILINE_COMMENT = 158;
+    static readonly RENAME_WS = 159;
+    static readonly SET_LINE_COMMENT = 160;
+    static readonly SET_MULTILINE_COMMENT = 161;
+    static readonly SET_WS = 162;
+    static readonly INFO = 163;
+    static readonly SHOW_LINE_COMMENT = 164;
+    static readonly SHOW_MULTILINE_COMMENT = 165;
+    static readonly SHOW_WS = 166;
+    static readonly EOF: number;
+    static readonly RULE_statements = 0;
+    static readonly RULE_singleStatement = 1;
+    static readonly RULE_query = 2;
+    static readonly RULE_sourceCommand = 3;
+    static readonly RULE_processingCommand = 4;
+    static readonly RULE_whereCommand = 5;
+    static readonly RULE_dataType = 6;
+    static readonly RULE_rowCommand = 7;
+    static readonly RULE_fields = 8;
+    static readonly RULE_field = 9;
+    static readonly RULE_fromCommand = 10;
+    static readonly RULE_timeSeriesCommand = 11;
+    static readonly RULE_externalCommand = 12;
+    static readonly RULE_indexPatternAndMetadataFields = 13;
+    static readonly RULE_indexPatternOrSubquery = 14;
+    static readonly RULE_subquery = 15;
+    static readonly RULE_indexPattern = 16;
+    static readonly RULE_clusterString = 17;
+    static readonly RULE_selectorString = 18;
+    static readonly RULE_unquotedIndexString = 19;
+    static readonly RULE_indexString = 20;
+    static readonly RULE_metadata = 21;
+    static readonly RULE_evalCommand = 22;
+    static readonly RULE_statsCommand = 23;
+    static readonly RULE_aggFields = 24;
+    static readonly RULE_aggField = 25;
+    static readonly RULE_qualifiedName = 26;
+    static readonly RULE_fieldName = 27;
+    static readonly RULE_qualifiedNamePattern = 28;
+    static readonly RULE_fieldNamePattern = 29;
+    static readonly RULE_qualifiedNamePatterns = 30;
+    static readonly RULE_identifier = 31;
+    static readonly RULE_identifierPattern = 32;
+    static readonly RULE_parameter = 33;
+    static readonly RULE_doubleParameter = 34;
+    static readonly RULE_identifierOrParameter = 35;
+    static readonly RULE_stringOrParameter = 36;
+    static readonly RULE_limitCommand = 37;
+    static readonly RULE_sortCommand = 38;
+    static readonly RULE_orderExpression = 39;
+    static readonly RULE_keepCommand = 40;
+    static readonly RULE_dropCommand = 41;
+    static readonly RULE_renameCommand = 42;
+    static readonly RULE_renameClause = 43;
+    static readonly RULE_dissectCommand = 44;
+    static readonly RULE_dissectCommandOptions = 45;
+    static readonly RULE_dissectCommandOption = 46;
+    static readonly RULE_commandNamedParameters = 47;
+    static readonly RULE_grokCommand = 48;
+    static readonly RULE_mvExpandCommand = 49;
+    static readonly RULE_explainCommand = 50;
+    static readonly RULE_subqueryExpression = 51;
+    static readonly RULE_showCommand = 52;
+    static readonly RULE_enrichCommand = 53;
+    static readonly RULE_enrichPolicyName = 54;
+    static readonly RULE_enrichWithClause = 55;
+    static readonly RULE_sampleCommand = 56;
+    static readonly RULE_changePointCommand = 57;
+    static readonly RULE_forkCommand = 58;
+    static readonly RULE_forkSubQueries = 59;
+    static readonly RULE_forkSubQuery = 60;
+    static readonly RULE_forkSubQueryCommand = 61;
+    static readonly RULE_forkSubQueryProcessingCommand = 62;
+    static readonly RULE_rerankCommand = 63;
+    static readonly RULE_completionCommand = 64;
+    static readonly RULE_inlineStatsCommand = 65;
+    static readonly RULE_fuseCommand = 66;
+    static readonly RULE_fuseConfiguration = 67;
+    static readonly RULE_fuseKeyByFields = 68;
+    static readonly RULE_metricsInfoCommand = 69;
+    static readonly RULE_lookupCommand = 70;
+    static readonly RULE_insistCommand = 71;
+    static readonly RULE_uriPartsCommand = 72;
+    static readonly RULE_setCommand = 73;
+    static readonly RULE_setField = 74;
+    static readonly RULE_mmrCommand = 75;
+    static readonly RULE_mmrQueryVectorParams = 76;
+    static readonly RULE_booleanExpression = 77;
+    static readonly RULE_regexBooleanExpression = 78;
+    static readonly RULE_matchBooleanExpression = 79;
+    static readonly RULE_valueExpression = 80;
+    static readonly RULE_operatorExpression = 81;
+    static readonly RULE_primaryExpression = 82;
+    static readonly RULE_functionExpression = 83;
+    static readonly RULE_functionName = 84;
+    static readonly RULE_mapExpression = 85;
+    static readonly RULE_entryExpression = 86;
+    static readonly RULE_mapValue = 87;
+    static readonly RULE_constant = 88;
+    static readonly RULE_booleanValue = 89;
+    static readonly RULE_numericValue = 90;
+    static readonly RULE_decimalValue = 91;
+    static readonly RULE_integerValue = 92;
+    static readonly RULE_string = 93;
+    static readonly RULE_comparisonOperator = 94;
+    static readonly RULE_joinCommand = 95;
+    static readonly RULE_joinTarget = 96;
+    static readonly RULE_joinCondition = 97;
+    static readonly RULE_promqlCommand = 98;
+    static readonly RULE_valueName = 99;
+    static readonly RULE_promqlParam = 100;
+    static readonly RULE_promqlParamName = 101;
+    static readonly RULE_promqlParamValue = 102;
+    static readonly RULE_promqlQueryContent = 103;
+    static readonly RULE_promqlQueryPart = 104;
+    static readonly RULE_promqlIndexPattern = 105;
+    static readonly RULE_promqlClusterString = 106;
+    static readonly RULE_promqlSelectorString = 107;
+    static readonly RULE_promqlUnquotedIndexString = 108;
+    static readonly RULE_promqlIndexString = 109;
+    static readonly literalNames: (string | null)[];
+    static readonly symbolicNames: (string | null)[];
+    static readonly ruleNames: string[];
+    get grammarFileName(): string;
+    get literalNames(): (string | null)[];
+    get symbolicNames(): (string | null)[];
+    get ruleNames(): string[];
+    get serializedATN(): number[];
+    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
+    constructor(input: TokenStream);
+    statements(): StatementsContext;
+    singleStatement(): SingleStatementContext;
+    query(): QueryContext;
+    query(_p: number): QueryContext;
+    sourceCommand(): SourceCommandContext;
+    processingCommand(): ProcessingCommandContext;
+    whereCommand(): WhereCommandContext;
+    dataType(): DataTypeContext;
+    rowCommand(): RowCommandContext;
+    fields(): FieldsContext;
+    field(): FieldContext;
+    fromCommand(): FromCommandContext;
+    timeSeriesCommand(): TimeSeriesCommandContext;
+    externalCommand(): ExternalCommandContext;
+    indexPatternAndMetadataFields(): IndexPatternAndMetadataFieldsContext;
+    indexPatternOrSubquery(): IndexPatternOrSubqueryContext;
+    subquery(): SubqueryContext;
+    indexPattern(): IndexPatternContext;
+    clusterString(): ClusterStringContext;
+    selectorString(): SelectorStringContext;
+    unquotedIndexString(): UnquotedIndexStringContext;
+    indexString(): IndexStringContext;
+    metadata(): MetadataContext;
+    evalCommand(): EvalCommandContext;
+    statsCommand(): StatsCommandContext;
+    aggFields(): AggFieldsContext;
+    aggField(): AggFieldContext;
+    qualifiedName(): QualifiedNameContext;
+    fieldName(): FieldNameContext;
+    qualifiedNamePattern(): QualifiedNamePatternContext;
+    fieldNamePattern(): FieldNamePatternContext;
+    qualifiedNamePatterns(): QualifiedNamePatternsContext;
+    identifier(): IdentifierContext;
+    identifierPattern(): IdentifierPatternContext;
+    parameter(): ParameterContext;
+    doubleParameter(): DoubleParameterContext;
+    identifierOrParameter(): IdentifierOrParameterContext;
+    stringOrParameter(): StringOrParameterContext;
+    limitCommand(): LimitCommandContext;
+    sortCommand(): SortCommandContext;
+    orderExpression(): OrderExpressionContext;
+    keepCommand(): KeepCommandContext;
+    dropCommand(): DropCommandContext;
+    renameCommand(): RenameCommandContext;
+    renameClause(): RenameClauseContext;
+    dissectCommand(): DissectCommandContext;
+    dissectCommandOptions(): DissectCommandOptionsContext;
+    dissectCommandOption(): DissectCommandOptionContext;
+    commandNamedParameters(): CommandNamedParametersContext;
+    grokCommand(): GrokCommandContext;
+    mvExpandCommand(): MvExpandCommandContext;
+    explainCommand(): ExplainCommandContext;
+    subqueryExpression(): SubqueryExpressionContext;
+    showCommand(): ShowCommandContext;
+    enrichCommand(): EnrichCommandContext;
+    enrichPolicyName(): EnrichPolicyNameContext;
+    enrichWithClause(): EnrichWithClauseContext;
+    sampleCommand(): SampleCommandContext;
+    changePointCommand(): ChangePointCommandContext;
+    forkCommand(): ForkCommandContext;
+    forkSubQueries(): ForkSubQueriesContext;
+    forkSubQuery(): ForkSubQueryContext;
+    forkSubQueryCommand(): ForkSubQueryCommandContext;
+    forkSubQueryCommand(_p: number): ForkSubQueryCommandContext;
+    forkSubQueryProcessingCommand(): ForkSubQueryProcessingCommandContext;
+    rerankCommand(): RerankCommandContext;
+    completionCommand(): CompletionCommandContext;
+    inlineStatsCommand(): InlineStatsCommandContext;
+    fuseCommand(): FuseCommandContext;
+    fuseConfiguration(): FuseConfigurationContext;
+    fuseKeyByFields(): FuseKeyByFieldsContext;
+    metricsInfoCommand(): MetricsInfoCommandContext;
+    lookupCommand(): LookupCommandContext;
+    insistCommand(): InsistCommandContext;
+    uriPartsCommand(): UriPartsCommandContext;
+    setCommand(): SetCommandContext;
+    setField(): SetFieldContext;
+    mmrCommand(): MmrCommandContext;
+    mmrQueryVectorParams(): MmrQueryVectorParamsContext;
+    booleanExpression(): BooleanExpressionContext;
+    booleanExpression(_p: number): BooleanExpressionContext;
+    regexBooleanExpression(): RegexBooleanExpressionContext;
+    matchBooleanExpression(): MatchBooleanExpressionContext;
+    valueExpression(): ValueExpressionContext;
+    operatorExpression(): OperatorExpressionContext;
+    operatorExpression(_p: number): OperatorExpressionContext;
+    primaryExpression(): PrimaryExpressionContext;
+    primaryExpression(_p: number): PrimaryExpressionContext;
+    functionExpression(): FunctionExpressionContext;
+    functionName(): FunctionNameContext;
+    mapExpression(): MapExpressionContext;
+    entryExpression(): EntryExpressionContext;
+    mapValue(): MapValueContext;
+    constant(): ConstantContext;
+    booleanValue(): BooleanValueContext;
+    numericValue(): NumericValueContext;
+    decimalValue(): DecimalValueContext;
+    integerValue(): IntegerValueContext;
+    string_(): StringContext;
+    comparisonOperator(): ComparisonOperatorContext;
+    joinCommand(): JoinCommandContext;
+    joinTarget(): JoinTargetContext;
+    joinCondition(): JoinConditionContext;
+    promqlCommand(): PromqlCommandContext;
+    valueName(): ValueNameContext;
+    promqlParam(): PromqlParamContext;
+    promqlParamName(): PromqlParamNameContext;
+    promqlParamValue(): PromqlParamValueContext;
+    promqlQueryContent(): PromqlQueryContentContext;
+    promqlQueryPart(): PromqlQueryPartContext;
+    promqlIndexPattern(): PromqlIndexPatternContext;
+    promqlClusterString(): PromqlClusterStringContext;
+    promqlSelectorString(): PromqlSelectorStringContext;
+    promqlUnquotedIndexString(): PromqlUnquotedIndexStringContext;
+    promqlIndexString(): PromqlIndexStringContext;
+    sempred(localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
+    private query_sempred;
+    private sourceCommand_sempred;
+    private processingCommand_sempred;
+    private indexPatternOrSubquery_sempred;
+    private qualifiedName_sempred;
+    private qualifiedNamePattern_sempred;
+    private forkSubQueryCommand_sempred;
+    private booleanExpression_sempred;
+    private operatorExpression_sempred;
+    private primaryExpression_sempred;
+    private joinTarget_sempred;
+    static readonly _serializedATN: number[];
+    private static __ATN;
+    static get _ATN(): ATN;
+    static DecisionsToDFA: DFA[];
+}
+export declare class StatementsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    singleStatement(): SingleStatementContext;
+    EOF(): TerminalNode;
+    setCommand_list(): SetCommandContext[];
+    setCommand(i: number): SetCommandContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SingleStatementContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    query(): QueryContext;
+    EOF(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class QueryContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: QueryContext): void;
+}
+export declare class CompositeQueryContext extends QueryContext {
+    constructor(parser: esql_parser, ctx: QueryContext);
+    query(): QueryContext;
+    PIPE(): TerminalNode;
+    processingCommand(): ProcessingCommandContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SingleCommandQueryContext extends QueryContext {
+    constructor(parser: esql_parser, ctx: QueryContext);
+    sourceCommand(): SourceCommandContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SourceCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    fromCommand(): FromCommandContext;
+    rowCommand(): RowCommandContext;
+    showCommand(): ShowCommandContext;
+    timeSeriesCommand(): TimeSeriesCommandContext;
+    promqlCommand(): PromqlCommandContext;
+    explainCommand(): ExplainCommandContext;
+    externalCommand(): ExternalCommandContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ProcessingCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    evalCommand(): EvalCommandContext;
+    whereCommand(): WhereCommandContext;
+    keepCommand(): KeepCommandContext;
+    limitCommand(): LimitCommandContext;
+    statsCommand(): StatsCommandContext;
+    sortCommand(): SortCommandContext;
+    dropCommand(): DropCommandContext;
+    renameCommand(): RenameCommandContext;
+    dissectCommand(): DissectCommandContext;
+    grokCommand(): GrokCommandContext;
+    enrichCommand(): EnrichCommandContext;
+    mvExpandCommand(): MvExpandCommandContext;
+    joinCommand(): JoinCommandContext;
+    changePointCommand(): ChangePointCommandContext;
+    completionCommand(): CompletionCommandContext;
+    sampleCommand(): SampleCommandContext;
+    forkCommand(): ForkCommandContext;
+    rerankCommand(): RerankCommandContext;
+    inlineStatsCommand(): InlineStatsCommandContext;
+    fuseCommand(): FuseCommandContext;
+    uriPartsCommand(): UriPartsCommandContext;
+    metricsInfoCommand(): MetricsInfoCommandContext;
+    lookupCommand(): LookupCommandContext;
+    insistCommand(): InsistCommandContext;
+    mmrCommand(): MmrCommandContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class WhereCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    WHERE(): TerminalNode;
+    booleanExpression(): BooleanExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DataTypeContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: DataTypeContext): void;
+}
+export declare class ToDataTypeContext extends DataTypeContext {
+    constructor(parser: esql_parser, ctx: DataTypeContext);
+    identifier(): IdentifierContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RowCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    ROW(): TerminalNode;
+    fields(): FieldsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FieldsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    field_list(): FieldContext[];
+    field(i: number): FieldContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FieldContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    booleanExpression(): BooleanExpressionContext;
+    qualifiedName(): QualifiedNameContext;
+    ASSIGN(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FromCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    FROM(): TerminalNode;
+    indexPatternAndMetadataFields(): IndexPatternAndMetadataFieldsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class TimeSeriesCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    TS(): TerminalNode;
+    indexPatternAndMetadataFields(): IndexPatternAndMetadataFieldsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ExternalCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    EXTERNAL(): TerminalNode;
+    stringOrParameter(): StringOrParameterContext;
+    commandNamedParameters(): CommandNamedParametersContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IndexPatternAndMetadataFieldsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    indexPatternOrSubquery_list(): IndexPatternOrSubqueryContext[];
+    indexPatternOrSubquery(i: number): IndexPatternOrSubqueryContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    metadata(): MetadataContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IndexPatternOrSubqueryContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    indexPattern(): IndexPatternContext;
+    subquery(): SubqueryContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SubqueryContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    LP(): TerminalNode;
+    fromCommand(): FromCommandContext;
+    RP(): TerminalNode;
+    PIPE_list(): TerminalNode[];
+    PIPE(i: number): TerminalNode;
+    processingCommand_list(): ProcessingCommandContext[];
+    processingCommand(i: number): ProcessingCommandContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IndexPatternContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    unquotedIndexString(): UnquotedIndexStringContext;
+    clusterString(): ClusterStringContext;
+    COLON(): TerminalNode;
+    CAST_OP(): TerminalNode;
+    selectorString(): SelectorStringContext;
+    indexString(): IndexStringContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ClusterStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_SOURCE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SelectorStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_SOURCE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class UnquotedIndexStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_SOURCE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IndexStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_SOURCE(): TerminalNode;
+    QUOTED_STRING(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MetadataContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    METADATA(): TerminalNode;
+    UNQUOTED_SOURCE_list(): TerminalNode[];
+    UNQUOTED_SOURCE(i: number): TerminalNode;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class EvalCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    EVAL(): TerminalNode;
+    fields(): FieldsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class StatsCommandContext extends ParserRuleContext {
+    _stats: AggFieldsContext;
+    _grouping: FieldsContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    STATS(): TerminalNode;
+    BY(): TerminalNode;
+    aggFields(): AggFieldsContext;
+    fields(): FieldsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class AggFieldsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    aggField_list(): AggFieldContext[];
+    aggField(i: number): AggFieldContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class AggFieldContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    field(): FieldContext;
+    WHERE(): TerminalNode;
+    booleanExpression(): BooleanExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class QualifiedNameContext extends ParserRuleContext {
+    _qualifier: Token;
+    _name: FieldNameContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    OPENING_BRACKET_list(): TerminalNode[];
+    OPENING_BRACKET(i: number): TerminalNode;
+    CLOSING_BRACKET_list(): TerminalNode[];
+    CLOSING_BRACKET(i: number): TerminalNode;
+    DOT(): TerminalNode;
+    fieldName(): FieldNameContext;
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FieldNameContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    identifierOrParameter_list(): IdentifierOrParameterContext[];
+    identifierOrParameter(i: number): IdentifierOrParameterContext;
+    DOT_list(): TerminalNode[];
+    DOT(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class QualifiedNamePatternContext extends ParserRuleContext {
+    _qualifier: Token;
+    _name: FieldNamePatternContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    OPENING_BRACKET_list(): TerminalNode[];
+    OPENING_BRACKET(i: number): TerminalNode;
+    CLOSING_BRACKET_list(): TerminalNode[];
+    CLOSING_BRACKET(i: number): TerminalNode;
+    DOT(): TerminalNode;
+    fieldNamePattern(): FieldNamePatternContext;
+    ID_PATTERN(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FieldNamePatternContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    identifierPattern_list(): IdentifierPatternContext[];
+    identifierPattern(i: number): IdentifierPatternContext;
+    DOT_list(): TerminalNode[];
+    DOT(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class QualifiedNamePatternsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    qualifiedNamePattern_list(): QualifiedNamePatternContext[];
+    qualifiedNamePattern(i: number): QualifiedNamePatternContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IdentifierContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    QUOTED_IDENTIFIER(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IdentifierPatternContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    ID_PATTERN(): TerminalNode;
+    parameter(): ParameterContext;
+    doubleParameter(): DoubleParameterContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ParameterContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ParameterContext): void;
+}
+export declare class InputNamedOrPositionalParamContext extends ParameterContext {
+    constructor(parser: esql_parser, ctx: ParameterContext);
+    NAMED_OR_POSITIONAL_PARAM(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class InputParamContext extends ParameterContext {
+    constructor(parser: esql_parser, ctx: ParameterContext);
+    PARAM(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DoubleParameterContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: DoubleParameterContext): void;
+}
+export declare class InputDoubleParamsContext extends DoubleParameterContext {
+    constructor(parser: esql_parser, ctx: DoubleParameterContext);
+    DOUBLE_PARAMS(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class InputNamedOrPositionalDoubleParamsContext extends DoubleParameterContext {
+    constructor(parser: esql_parser, ctx: DoubleParameterContext);
+    NAMED_OR_POSITIONAL_DOUBLE_PARAMS(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IdentifierOrParameterContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    identifier(): IdentifierContext;
+    parameter(): ParameterContext;
+    doubleParameter(): DoubleParameterContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class StringOrParameterContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    string_(): StringContext;
+    parameter(): ParameterContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class LimitCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    LIMIT(): TerminalNode;
+    constant(): ConstantContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SortCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    SORT(): TerminalNode;
+    orderExpression_list(): OrderExpressionContext[];
+    orderExpression(i: number): OrderExpressionContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class OrderExpressionContext extends ParserRuleContext {
+    _ordering: Token;
+    _nullOrdering: Token;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    booleanExpression(): BooleanExpressionContext;
+    NULLS(): TerminalNode;
+    ASC(): TerminalNode;
+    DESC(): TerminalNode;
+    FIRST(): TerminalNode;
+    LAST(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class KeepCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    KEEP(): TerminalNode;
+    qualifiedNamePatterns(): QualifiedNamePatternsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DropCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    DROP(): TerminalNode;
+    qualifiedNamePatterns(): QualifiedNamePatternsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RenameCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    RENAME(): TerminalNode;
+    renameClause_list(): RenameClauseContext[];
+    renameClause(i: number): RenameClauseContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RenameClauseContext extends ParserRuleContext {
+    _oldName: QualifiedNamePatternContext;
+    _newName: QualifiedNamePatternContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    AS(): TerminalNode;
+    qualifiedNamePattern_list(): QualifiedNamePatternContext[];
+    qualifiedNamePattern(i: number): QualifiedNamePatternContext;
+    ASSIGN(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DissectCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    DISSECT(): TerminalNode;
+    primaryExpression(): PrimaryExpressionContext;
+    string_(): StringContext;
+    dissectCommandOptions(): DissectCommandOptionsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DissectCommandOptionsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    dissectCommandOption_list(): DissectCommandOptionContext[];
+    dissectCommandOption(i: number): DissectCommandOptionContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DissectCommandOptionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    identifier(): IdentifierContext;
+    ASSIGN(): TerminalNode;
+    constant(): ConstantContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class CommandNamedParametersContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    WITH(): TerminalNode;
+    mapExpression(): MapExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class GrokCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    GROK(): TerminalNode;
+    primaryExpression(): PrimaryExpressionContext;
+    string__list(): StringContext[];
+    string_(i: number): StringContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MvExpandCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    MV_EXPAND(): TerminalNode;
+    qualifiedName(): QualifiedNameContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ExplainCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    DEV_EXPLAIN(): TerminalNode;
+    subqueryExpression(): SubqueryExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SubqueryExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    LP(): TerminalNode;
+    query(): QueryContext;
+    RP(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ShowCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ShowCommandContext): void;
+}
+export declare class ShowInfoContext extends ShowCommandContext {
+    constructor(parser: esql_parser, ctx: ShowCommandContext);
+    SHOW(): TerminalNode;
+    INFO(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class EnrichCommandContext extends ParserRuleContext {
+    _policyName: EnrichPolicyNameContext;
+    _matchField: QualifiedNamePatternContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    ENRICH(): TerminalNode;
+    enrichPolicyName(): EnrichPolicyNameContext;
+    ON(): TerminalNode;
+    WITH(): TerminalNode;
+    enrichWithClause_list(): EnrichWithClauseContext[];
+    enrichWithClause(i: number): EnrichWithClauseContext;
+    qualifiedNamePattern(): QualifiedNamePatternContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class EnrichPolicyNameContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    ENRICH_POLICY_NAME(): TerminalNode;
+    QUOTED_STRING(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class EnrichWithClauseContext extends ParserRuleContext {
+    _newName: QualifiedNamePatternContext;
+    _enrichField: QualifiedNamePatternContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    qualifiedNamePattern_list(): QualifiedNamePatternContext[];
+    qualifiedNamePattern(i: number): QualifiedNamePatternContext;
+    ASSIGN(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SampleCommandContext extends ParserRuleContext {
+    _probability: ConstantContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    SAMPLE(): TerminalNode;
+    constant(): ConstantContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ChangePointCommandContext extends ParserRuleContext {
+    _value: QualifiedNameContext;
+    _key: QualifiedNameContext;
+    _targetType: QualifiedNameContext;
+    _targetPvalue: QualifiedNameContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    CHANGE_POINT(): TerminalNode;
+    qualifiedName_list(): QualifiedNameContext[];
+    qualifiedName(i: number): QualifiedNameContext;
+    ON(): TerminalNode;
+    AS(): TerminalNode;
+    COMMA(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ForkCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    FORK(): TerminalNode;
+    forkSubQueries(): ForkSubQueriesContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ForkSubQueriesContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    forkSubQuery_list(): ForkSubQueryContext[];
+    forkSubQuery(i: number): ForkSubQueryContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ForkSubQueryContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    LP(): TerminalNode;
+    forkSubQueryCommand(): ForkSubQueryCommandContext;
+    RP(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ForkSubQueryCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ForkSubQueryCommandContext): void;
+}
+export declare class SingleForkSubQueryCommandContext extends ForkSubQueryCommandContext {
+    constructor(parser: esql_parser, ctx: ForkSubQueryCommandContext);
+    forkSubQueryProcessingCommand(): ForkSubQueryProcessingCommandContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class CompositeForkSubQueryContext extends ForkSubQueryCommandContext {
+    constructor(parser: esql_parser, ctx: ForkSubQueryCommandContext);
+    forkSubQueryCommand(): ForkSubQueryCommandContext;
+    PIPE(): TerminalNode;
+    forkSubQueryProcessingCommand(): ForkSubQueryProcessingCommandContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ForkSubQueryProcessingCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    processingCommand(): ProcessingCommandContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RerankCommandContext extends ParserRuleContext {
+    _targetField: QualifiedNameContext;
+    _queryText: ConstantContext;
+    _rerankFields: FieldsContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    RERANK(): TerminalNode;
+    ON(): TerminalNode;
+    commandNamedParameters(): CommandNamedParametersContext;
+    constant(): ConstantContext;
+    fields(): FieldsContext;
+    ASSIGN(): TerminalNode;
+    qualifiedName(): QualifiedNameContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class CompletionCommandContext extends ParserRuleContext {
+    _targetField: QualifiedNameContext;
+    _prompt: PrimaryExpressionContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    COMPLETION(): TerminalNode;
+    commandNamedParameters(): CommandNamedParametersContext;
+    primaryExpression(): PrimaryExpressionContext;
+    ASSIGN(): TerminalNode;
+    qualifiedName(): QualifiedNameContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class InlineStatsCommandContext extends ParserRuleContext {
+    _stats: AggFieldsContext;
+    _grouping: FieldsContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    INLINE(): TerminalNode;
+    INLINE_STATS(): TerminalNode;
+    aggFields(): AggFieldsContext;
+    BY(): TerminalNode;
+    fields(): FieldsContext;
+    INLINESTATS(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FuseCommandContext extends ParserRuleContext {
+    _fuseType: IdentifierContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    FUSE(): TerminalNode;
+    fuseConfiguration_list(): FuseConfigurationContext[];
+    fuseConfiguration(i: number): FuseConfigurationContext;
+    identifier(): IdentifierContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FuseConfigurationContext extends ParserRuleContext {
+    _score: QualifiedNameContext;
+    _key: FuseKeyByFieldsContext;
+    _group: QualifiedNameContext;
+    _options: MapExpressionContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    SCORE(): TerminalNode;
+    BY(): TerminalNode;
+    qualifiedName(): QualifiedNameContext;
+    KEY(): TerminalNode;
+    fuseKeyByFields(): FuseKeyByFieldsContext;
+    GROUP(): TerminalNode;
+    WITH(): TerminalNode;
+    mapExpression(): MapExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FuseKeyByFieldsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    qualifiedName_list(): QualifiedNameContext[];
+    qualifiedName(i: number): QualifiedNameContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MetricsInfoCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    METRICS_INFO(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class LookupCommandContext extends ParserRuleContext {
+    _tableName: IndexPatternContext;
+    _matchFields: QualifiedNamePatternsContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    DEV_LOOKUP(): TerminalNode;
+    ON(): TerminalNode;
+    indexPattern(): IndexPatternContext;
+    qualifiedNamePatterns(): QualifiedNamePatternsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class InsistCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    DEV_INSIST(): TerminalNode;
+    qualifiedNamePatterns(): QualifiedNamePatternsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class UriPartsCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    URI_PARTS(): TerminalNode;
+    qualifiedName(): QualifiedNameContext;
+    ASSIGN(): TerminalNode;
+    primaryExpression(): PrimaryExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SetCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    SET(): TerminalNode;
+    setField(): SetFieldContext;
+    SEMICOLON(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class SetFieldContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    identifier(): IdentifierContext;
+    ASSIGN(): TerminalNode;
+    constant(): ConstantContext;
+    mapExpression(): MapExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MmrCommandContext extends ParserRuleContext {
+    _queryVector: MmrQueryVectorParamsContext;
+    _diversifyField: QualifiedNameContext;
+    _limitValue: IntegerValueContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    DEV_MMR(): TerminalNode;
+    ON(): TerminalNode;
+    MMR_LIMIT(): TerminalNode;
+    commandNamedParameters(): CommandNamedParametersContext;
+    qualifiedName(): QualifiedNameContext;
+    integerValue(): IntegerValueContext;
+    mmrQueryVectorParams(): MmrQueryVectorParamsContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MmrQueryVectorParamsContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: MmrQueryVectorParamsContext): void;
+}
+export declare class MmrQueryVectorParameterContext extends MmrQueryVectorParamsContext {
+    constructor(parser: esql_parser, ctx: MmrQueryVectorParamsContext);
+    parameter(): ParameterContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MmrQueryVectorExpressionContext extends MmrQueryVectorParamsContext {
+    constructor(parser: esql_parser, ctx: MmrQueryVectorParamsContext);
+    primaryExpression(): PrimaryExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class BooleanExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: BooleanExpressionContext): void;
+}
+export declare class MatchExpressionContext extends BooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: BooleanExpressionContext);
+    matchBooleanExpression(): MatchBooleanExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class LogicalNotContext extends BooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: BooleanExpressionContext);
+    NOT(): TerminalNode;
+    booleanExpression(): BooleanExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class BooleanDefaultContext extends BooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: BooleanExpressionContext);
+    valueExpression(): ValueExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IsNullContext extends BooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: BooleanExpressionContext);
+    valueExpression(): ValueExpressionContext;
+    IS(): TerminalNode;
+    NULL(): TerminalNode;
+    NOT(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RegexExpressionContext extends BooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: BooleanExpressionContext);
+    regexBooleanExpression(): RegexBooleanExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class LogicalInContext extends BooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: BooleanExpressionContext);
+    valueExpression_list(): ValueExpressionContext[];
+    valueExpression(i: number): ValueExpressionContext;
+    IN(): TerminalNode;
+    LP(): TerminalNode;
+    RP(): TerminalNode;
+    NOT(): TerminalNode;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class LogicalBinaryContext extends BooleanExpressionContext {
+    _left: BooleanExpressionContext;
+    _operator: Token;
+    _right: BooleanExpressionContext;
+    constructor(parser: esql_parser, ctx: BooleanExpressionContext);
+    booleanExpression_list(): BooleanExpressionContext[];
+    booleanExpression(i: number): BooleanExpressionContext;
+    AND(): TerminalNode;
+    OR(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RegexBooleanExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: RegexBooleanExpressionContext): void;
+}
+export declare class LikeExpressionContext extends RegexBooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: RegexBooleanExpressionContext);
+    valueExpression(): ValueExpressionContext;
+    LIKE(): TerminalNode;
+    stringOrParameter(): StringOrParameterContext;
+    NOT(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class LikeListExpressionContext extends RegexBooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: RegexBooleanExpressionContext);
+    valueExpression(): ValueExpressionContext;
+    LIKE(): TerminalNode;
+    LP(): TerminalNode;
+    stringOrParameter_list(): StringOrParameterContext[];
+    stringOrParameter(i: number): StringOrParameterContext;
+    RP(): TerminalNode;
+    NOT(): TerminalNode;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RlikeExpressionContext extends RegexBooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: RegexBooleanExpressionContext);
+    valueExpression(): ValueExpressionContext;
+    RLIKE(): TerminalNode;
+    stringOrParameter(): StringOrParameterContext;
+    NOT(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class RlikeListExpressionContext extends RegexBooleanExpressionContext {
+    constructor(parser: esql_parser, ctx: RegexBooleanExpressionContext);
+    valueExpression(): ValueExpressionContext;
+    RLIKE(): TerminalNode;
+    LP(): TerminalNode;
+    stringOrParameter_list(): StringOrParameterContext[];
+    stringOrParameter(i: number): StringOrParameterContext;
+    RP(): TerminalNode;
+    NOT(): TerminalNode;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MatchBooleanExpressionContext extends ParserRuleContext {
+    _fieldExp: QualifiedNameContext;
+    _fieldType: DataTypeContext;
+    _matchQuery: ConstantContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    COLON(): TerminalNode;
+    qualifiedName(): QualifiedNameContext;
+    constant(): ConstantContext;
+    CAST_OP(): TerminalNode;
+    dataType(): DataTypeContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ValueExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ValueExpressionContext): void;
+}
+export declare class ValueExpressionDefaultContext extends ValueExpressionContext {
+    constructor(parser: esql_parser, ctx: ValueExpressionContext);
+    operatorExpression(): OperatorExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ComparisonContext extends ValueExpressionContext {
+    _left: OperatorExpressionContext;
+    _right: OperatorExpressionContext;
+    constructor(parser: esql_parser, ctx: ValueExpressionContext);
+    comparisonOperator(): ComparisonOperatorContext;
+    operatorExpression_list(): OperatorExpressionContext[];
+    operatorExpression(i: number): OperatorExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class OperatorExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: OperatorExpressionContext): void;
+}
+export declare class OperatorExpressionDefaultContext extends OperatorExpressionContext {
+    constructor(parser: esql_parser, ctx: OperatorExpressionContext);
+    primaryExpression(): PrimaryExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ArithmeticBinaryContext extends OperatorExpressionContext {
+    _left: OperatorExpressionContext;
+    _operator: Token;
+    _right: OperatorExpressionContext;
+    constructor(parser: esql_parser, ctx: OperatorExpressionContext);
+    operatorExpression_list(): OperatorExpressionContext[];
+    operatorExpression(i: number): OperatorExpressionContext;
+    ASTERISK(): TerminalNode;
+    SLASH(): TerminalNode;
+    PERCENT(): TerminalNode;
+    PLUS(): TerminalNode;
+    MINUS(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ArithmeticUnaryContext extends OperatorExpressionContext {
+    _operator: Token;
+    constructor(parser: esql_parser, ctx: OperatorExpressionContext);
+    operatorExpression(): OperatorExpressionContext;
+    MINUS(): TerminalNode;
+    PLUS(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PrimaryExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: PrimaryExpressionContext): void;
+}
+export declare class DereferenceContext extends PrimaryExpressionContext {
+    constructor(parser: esql_parser, ctx: PrimaryExpressionContext);
+    qualifiedName(): QualifiedNameContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class InlineCastContext extends PrimaryExpressionContext {
+    constructor(parser: esql_parser, ctx: PrimaryExpressionContext);
+    primaryExpression(): PrimaryExpressionContext;
+    CAST_OP(): TerminalNode;
+    dataType(): DataTypeContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ConstantDefaultContext extends PrimaryExpressionContext {
+    constructor(parser: esql_parser, ctx: PrimaryExpressionContext);
+    constant(): ConstantContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ParenthesizedExpressionContext extends PrimaryExpressionContext {
+    constructor(parser: esql_parser, ctx: PrimaryExpressionContext);
+    LP(): TerminalNode;
+    booleanExpression(): BooleanExpressionContext;
+    RP(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FunctionContext extends PrimaryExpressionContext {
+    constructor(parser: esql_parser, ctx: PrimaryExpressionContext);
+    functionExpression(): FunctionExpressionContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FunctionExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    functionName(): FunctionNameContext;
+    LP(): TerminalNode;
+    RP(): TerminalNode;
+    ASTERISK(): TerminalNode;
+    booleanExpression_list(): BooleanExpressionContext[];
+    booleanExpression(i: number): BooleanExpressionContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    mapExpression(): MapExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class FunctionNameContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    identifierOrParameter(): IdentifierOrParameterContext;
+    FIRST(): TerminalNode;
+    LAST(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MapExpressionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    LEFT_BRACES(): TerminalNode;
+    RIGHT_BRACES(): TerminalNode;
+    entryExpression_list(): EntryExpressionContext[];
+    entryExpression(i: number): EntryExpressionContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class EntryExpressionContext extends ParserRuleContext {
+    _key: StringContext;
+    _value: MapValueContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    COLON(): TerminalNode;
+    string_(): StringContext;
+    mapValue(): MapValueContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class MapValueContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    constant(): ConstantContext;
+    mapExpression(): MapExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ConstantContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ConstantContext): void;
+}
+export declare class BooleanArrayLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    OPENING_BRACKET(): TerminalNode;
+    booleanValue_list(): BooleanValueContext[];
+    booleanValue(i: number): BooleanValueContext;
+    CLOSING_BRACKET(): TerminalNode;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DecimalLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    decimalValue(): DecimalValueContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class NullLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    NULL(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class QualifiedIntegerLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    integerValue(): IntegerValueContext;
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class StringArrayLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    OPENING_BRACKET(): TerminalNode;
+    string__list(): StringContext[];
+    string_(i: number): StringContext;
+    CLOSING_BRACKET(): TerminalNode;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class InputParameterContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    parameter(): ParameterContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class StringLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    string_(): StringContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class NumericArrayLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    OPENING_BRACKET(): TerminalNode;
+    numericValue_list(): NumericValueContext[];
+    numericValue(i: number): NumericValueContext;
+    CLOSING_BRACKET(): TerminalNode;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IntegerLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    integerValue(): IntegerValueContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class BooleanLiteralContext extends ConstantContext {
+    constructor(parser: esql_parser, ctx: ConstantContext);
+    booleanValue(): BooleanValueContext;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class BooleanValueContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    TRUE(): TerminalNode;
+    FALSE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class NumericValueContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    decimalValue(): DecimalValueContext;
+    integerValue(): IntegerValueContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class DecimalValueContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    DECIMAL_LITERAL(): TerminalNode;
+    PLUS(): TerminalNode;
+    MINUS(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class IntegerValueContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    INTEGER_LITERAL(): TerminalNode;
+    PLUS(): TerminalNode;
+    MINUS(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class StringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    QUOTED_STRING(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ComparisonOperatorContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    EQ(): TerminalNode;
+    NEQ(): TerminalNode;
+    LT(): TerminalNode;
+    LTE(): TerminalNode;
+    GT(): TerminalNode;
+    GTE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class JoinCommandContext extends ParserRuleContext {
+    _type_: Token;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    JOIN(): TerminalNode;
+    joinTarget(): JoinTargetContext;
+    joinCondition(): JoinConditionContext;
+    JOIN_LOOKUP(): TerminalNode;
+    DEV_JOIN_LEFT(): TerminalNode;
+    DEV_JOIN_RIGHT(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class JoinTargetContext extends ParserRuleContext {
+    _index: IndexPatternContext;
+    _qualifier: Token;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    indexPattern(): IndexPatternContext;
+    UNQUOTED_SOURCE(): TerminalNode;
+    AS(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class JoinConditionContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    ON(): TerminalNode;
+    booleanExpression_list(): BooleanExpressionContext[];
+    booleanExpression(i: number): BooleanExpressionContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlCommandContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    PROMQL(): TerminalNode;
+    LP(): TerminalNode;
+    RP(): TerminalNode;
+    promqlParam_list(): PromqlParamContext[];
+    promqlParam(i: number): PromqlParamContext;
+    valueName(): ValueNameContext;
+    ASSIGN(): TerminalNode;
+    promqlQueryPart_list(): PromqlQueryPartContext[];
+    promqlQueryPart(i: number): PromqlQueryPartContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class ValueNameContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    QUOTED_IDENTIFIER(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlParamContext extends ParserRuleContext {
+    _name: PromqlParamNameContext;
+    _value: PromqlParamValueContext;
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    ASSIGN(): TerminalNode;
+    promqlParamName(): PromqlParamNameContext;
+    promqlParamValue(): PromqlParamValueContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlParamNameContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    QUOTED_IDENTIFIER(): TerminalNode;
+    QUOTED_STRING(): TerminalNode;
+    NAMED_OR_POSITIONAL_PARAM(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlParamValueContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    promqlIndexPattern_list(): PromqlIndexPatternContext[];
+    promqlIndexPattern(i: number): PromqlIndexPatternContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    QUOTED_IDENTIFIER(): TerminalNode;
+    NAMED_OR_POSITIONAL_PARAM(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlQueryContentContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_SOURCE(): TerminalNode;
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    QUOTED_STRING(): TerminalNode;
+    QUOTED_IDENTIFIER(): TerminalNode;
+    NAMED_OR_POSITIONAL_PARAM(): TerminalNode;
+    PROMQL_QUERY_COMMENT(): TerminalNode;
+    PROMQL_SINGLE_QUOTED_STRING(): TerminalNode;
+    ASSIGN(): TerminalNode;
+    COMMA(): TerminalNode;
+    COLON(): TerminalNode;
+    CAST_OP(): TerminalNode;
+    PROMQL_OTHER_QUERY_CONTENT(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlQueryPartContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    promqlQueryContent_list(): PromqlQueryContentContext[];
+    promqlQueryContent(i: number): PromqlQueryContentContext;
+    LP(): TerminalNode;
+    RP(): TerminalNode;
+    promqlQueryPart_list(): PromqlQueryPartContext[];
+    promqlQueryPart(i: number): PromqlQueryPartContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlIndexPatternContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    promqlClusterString(): PromqlClusterStringContext;
+    COLON(): TerminalNode;
+    promqlUnquotedIndexString(): PromqlUnquotedIndexStringContext;
+    CAST_OP(): TerminalNode;
+    promqlSelectorString(): PromqlSelectorStringContext;
+    promqlIndexString(): PromqlIndexStringContext;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlClusterStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    UNQUOTED_SOURCE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlSelectorStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    UNQUOTED_SOURCE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlUnquotedIndexStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    UNQUOTED_SOURCE(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+export declare class PromqlIndexStringContext extends ParserRuleContext {
+    constructor(parser?: esql_parser, parent?: ParserRuleContext, invokingState?: number);
+    UNQUOTED_IDENTIFIER(): TerminalNode;
+    UNQUOTED_SOURCE(): TerminalNode;
+    QUOTED_STRING(): TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: esql_parserListener): void;
+    exitRule(listener: esql_parserListener): void;
+}
+//# sourceMappingURL=esql_parser.d.ts.map