@hamelin.sh/compiler 0.2.9 → 0.2.11

package/dist/main.d.ts

@@ -1,48 +1,30 @@
-import * as antlr from 'antlr4ng';
-import { AbstractParseTreeVisitor, Token, ParseTreeListener, TerminalNode, ErrorNode, ParserRuleContext } from 'antlr4ng';
-
 /* tslint:disable */
 /* eslint-disable */
 type CompileQueryResult = { Ok: QueryTranslation } | { Err: ContextualTranslationErrors };
 
 type QueryDatasetsResult = { Ok: string[] } | { Err: ContextualTranslationErrors };
 
-interface FunctionDescription {
-    name: string;
-    parameters: string;
-}
-
-interface ContextualTranslationErrors {
-    hamelin: string;
-    errors: ContextualTranslationError[];
+interface Completion {
+    at: { start: number; end: number };
+    filter: boolean | undefined;
+    items: CompletionItem[];
 }
 
-type TranslationErrors = TranslationError[];
-
-interface Context {
-    interval: { start: number; end: number };
-    message: string;
+interface Translation {
+    sql: string;
+    columns: Column[];
 }
 
-interface ContextualTranslationError {
-    error: TranslationError;
+interface ContextualCompletion {
     pretty: string;
+    completion: Completion;
 }
 
-interface TranslationError {
-    area: LanguageArea | undefined;
-    stage: Stage;
-    level: Level;
-    primary: Context;
-    supporting: Context[] | undefined;
-    source_desc: string | undefined;
-}
-
-type Stage = "Translation" | "Parsing" | "SemanticAnalysis";
-
-type LanguageArea = "FunctionCall" | "Operator" | "Deref" | "IndexAccess" | "Parsing";
+type CompletionItemKind = "Text" | "Variable" | "Function" | "Command" | "Keyword";
 
-type Level = "Error" | "Warning" | "Info";
+interface QueryTranslation {
+    translation: Translation;
+}
 
 interface ContextualResult {
     hamelin: string;
@@ -51,13 +33,6 @@ interface ContextualResult {
     translation: QueryTranslation | undefined;
 }
 
-interface ContextualCompletion {
-    pretty: string;
-    completion: Completion;
-}
-
-type CompletionItemKind = "Text" | "Variable" | "Function" | "Command" | "Keyword";
-
 interface CompletionItem {
     /**
      * What to show
@@ -86,35 +61,49 @@ interface CompletionItem {
     section: string | undefined;
 }
 
-interface Completion {
-    at: { start: number; end: number };
-    filter: boolean | undefined;
-    items: CompletionItem[];
+type Level = "Error" | "Warning" | "Info";
+
+interface TranslationError {
+    area: LanguageArea | undefined;
+    stage: Stage;
+    level: Level;
+    primary: Context;
+    supporting: Context[] | undefined;
+    source_desc: string | undefined;
 }
 
-interface Translation {
-    sql: string;
-    columns: Column[];
+interface ContextualTranslationErrors {
+    hamelin: string;
+    errors: ContextualTranslationError[];
 }
 
-interface DMLTranslation {
-    translation: Translation;
+type LanguageArea = "FunctionCall" | "Operator" | "Deref" | "IndexAccess" | "Parsing";
+
+interface Context {
+    interval: { start: number; end: number };
+    message: string;
 }
 
-interface QueryTranslation {
-    translation: Translation;
+interface ContextualTranslationError {
+    error: TranslationError;
+    pretty: string;
 }
 
-type StatementTranslation = { Query: QueryTranslation } | { DML: DMLTranslation };
+type Stage = "Translation" | "Parsing" | "SemanticAnalysis";
 
-type HamelinType = "binary" | "boolean" | "interval" | "calendar_interval" | "int" | "double" | "rows" | "string" | "timestamp" | "unknown" | { decimal: { precision: number; scale: number } } | { array: { element_type: HamelinType } } | { map: { key_type: HamelinType; value_type: HamelinType } } | { tuple: { elements: HamelinType[] } } | "variant" | { range: { of: HamelinType } } | { struct: Column[] };
+interface FunctionDescription {
+    name: string;
+    parameters: string;
+}
+
+type Catalog = Record<string, Column[]>;
 
 interface Column {
     name: string;
     type: HamelinType;
 }
 
-type Catalog = Record<string, Column[]>;
+type HamelinType = "binary" | "boolean" | "interval" | "calendar_interval" | "int" | "double" | "rows" | "string" | "timestamp" | "unknown" | { decimal: { precision: number; scale: number } } | { array: { element_type: HamelinType } } | { map: { key_type: HamelinType; value_type: HamelinType } } | { tuple: { elements: HamelinType[] } } | "variant" | { range: { of: HamelinType } } | { struct: Column[] };
 
 declare class CatalogProvider {
   private constructor();
@@ -125,2860 +114,68 @@ declare class CatalogProvider {
 declare class Compiler {
   free(): void;
   [Symbol.dispose](): void;
-  constructor();
-  get_function_descriptions(): FunctionDescription[];
-  set_catalog_provider(provider: CatalogProvider): void;
-  set_time_range(start?: Date | null, end?: Date | null): void;
-  set_time_range_expression(expression: string): ContextualTranslationErrors | undefined;
   compile_query(query: string): CompileQueryResult;
+  set_time_range(start?: Date | null, end?: Date | null): void;
   compile_query_at(query: string, at?: number | null): ContextualResult;
+  set_catalog_provider(provider: CatalogProvider): void;
   get_statement_datasets(query: string): QueryDatasetsResult;
+  get_function_descriptions(): FunctionDescription[];
+  set_time_range_expression(expression: string): ContextualTranslationErrors | undefined;
+  constructor();
 }
 
-type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+declare const compileHamelin: (catalog: Catalog, hamelinInput: string, timeRange?: string) => Promise<CompileQueryResult>;
+declare const createCompiler: (catalog: Catalog) => Promise<Compiler>;
+
+declare const hamelinGrammar = "grammar Hamelin;\n\nidentifierEOF\n    : identifier EOF\n    ;\n\nqueryEOF\n    : query EOF\n    ;\n\ncommandEOF\n    : command EOF\n    ;\n\nexpressionEOF\n    : expression EOF\n    ;\n\npipelineEOF\n    : pipeline EOF\n    ;\n\nsimpleIdentifierEOF\n    : simpleIdentifier EOF\n    ;\n\nquery\n    : (WITH simpleIdentifier ASSIGN pipeline)+ pipeline                                 #withQuery\n    | pipeline                                                                          #standaloneQuery\n    | expression                                                                        #expressionQuery\n    ;\n\npipeline\n    : command ( PIPE command )*                                                         #pipelineAlt\n    ;\n\ncommand\n    : LET_COMMAND assignment (COMMA assignment)* COMMA?                                 #letCommand\n    | WHERE_COMMAND expression                                                          #whereCommand\n    | SELECT_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?                  #selectCommand\n    | DROP_COMMAND selection (COMMA selection)* COMMA?                                  #dropCommand\n    | FROM_COMMAND fromClause (COMMA fromClause)* COMMA?                                #fromCommand\n    | UNION_COMMAND fromClause (COMMA fromClause)* COMMA?                               #unionCommand\n    | LIMIT_COMMAND expression                                                          #limitCommand\n    | PARSE_COMMAND src=expression? string\n                    AS? identifier (COMMA identifier)* COMMA? NODROP?                   #parseCommand\n    | WITHIN_COMMAND expression                                                         #withinCommand\n    | AGG_COMMAND (assignmentClause (COMMA assignmentClause)*)? COMMA?\n                  (BY groupClause (COMMA groupClause)*)? COMMA?\n                  (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?             #aggCommand\n    | SORT BY? sortExpression (COMMA sortExpression)* COMMA?                            #sortCommand\n    | WINDOW_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?\n                     (BY groupClause (COMMA groupClause)*)? COMMA?\n                     (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?\n                     (WITHIN_COMMAND within=expression)?                                #windowCommand\n    | APPEND_COMMAND tableReference (DISTINCT_BY selection (COMMA selection)*)? COMMA?  #appendCommand\n    | (JOIN_COMMAND | LOOKUP_COMMAND) fromClause (ON on=expression)?                    #joinCommand\n    | EXPLODE_COMMAND assignmentClause                                                  #explodeCommand\n    | (UNNEST_COMMAND | ROWS_COMMAND) expression                                        #unnestCommand\n    | NEST_COMMAND identifier                                                           #nestCommand\n    | MATCH_COMMAND pattern+\n                    (WHEN matchDefine (COMMA matchDefine)*)? COMMA?\n                    (BY groupClause (COMMA groupClause)*)? COMMA?\n                    (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?           #matchCommand\n    ;\n\nassignmentClause: assignment | expression;\ngroupClause: assignmentClause;\nassignment: identifier ASSIGN expression;\nmatchDefine: simpleIdentifier ASSIGN expression;\nselection: identifier;\nsortExpression: expression (ASC | DESC)?;\ntableAlias: simpleIdentifier ASSIGN tableReference;\nfromClause: tableAlias | tableReference;\n\nexpression\n    // Keep this list in precedence order (important!)\n    : operator=(MINUS | PLUS) expression                                                #unaryPrefixOperator\n    | expression (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |\n                  MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                             #tsTrunc\n    | left=expression operator=DOT right=simpleIdentifier                               #deref\n    | value=expression LBRACKET index=expression RBRACKET                               #indexAccess\n    | left=expression operator=(ASTERISK | SLASH | PERCENT) right=expression            #binaryOperator\n    | left=expression operator=(PLUS | MINUS) right=expression                          #binaryOperator\n    | operator=RANGE expression                                                         #unaryPrefixOperator\n    | expression operator=RANGE                                                         #unaryPostfixOperator\n    | left=expression operator=RANGE right=expression                                   #binaryOperator\n    | left=expression operator=AS right=hamelintype                                     #cast\n    | left=expression\n        operator=(EQ | NEQ | LT | LTE | GT | GTE | IS | ISNOT | IN | NOTIN)\n        right=expression                                                                #binaryOperator\n    | operator=NOT expression                                                           #unaryPrefixOperator\n    | left=expression operator=AND right=expression                                     #binaryOperator\n    | left=expression operator=OR right=expression                                      #binaryOperator\n\n    // Complex Literals\n    | left=expression operator=COLON right=expression                                   #pairLiteral\n    | LCURLY simpleIdentifier COLON expression\n      (COMMA simpleIdentifier COLON expression)* COMMA? RCURLY                          #structLiteral\n    | LPARENS ((expression COMMA) |\n               (expression COMMA expression (COMMA expression)* COMMA?)) RPARENS        #tupleLiteral\n    | LBRACKET (expression (COMMA expression)* COMMA?)? RBRACKET                        #arrayLiteral\n\n    // Function Calls\n    | functionName=simpleIdentifier\n        LPARENS (namedArgument (COMMA namedArgument)* COMMA?)? RPARENS                  #functionCall\n    | functionName=simpleIdentifier LPARENS\n        positionalArgument (COMMA positionalArgument)*\n                           (COMMA namedArgument)* COMMA? RPARENS                        #functionCall\n\n    // Primitive Literals\n    | NULL                                                                              #nullLiteral\n    | number                                                                            #numericLiteral\n    | TRUE                                                                              #booleanLiteral\n    | FALSE                                                                             #booleanLiteral\n    | string                                                                            #stringLiteral\n    | BINARY_LITERAL                                                                    #binaryLiteral\n    | RANGE                                                                             #unboundRangeLiteral\n    | (NANOSECOND_INTERVAL | MICROSECOND_INTERVAL | MILLISECOND_INTERVAL |\n       SECOND_INTERVAL | MINUTE_INTERVAL | HOUR_INTERVAL | DAY_INTERVAL |\n       WEEK_INTERVAL | MONTH_INTERVAL | QUARTER_INTERVAL | YEAR_INTERVAL)               #intervalLiteral\n    | ROWS_LITERAL                                                                      #rowsLiteral\n    | (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |\n       MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                                        #tsTruncTimestampLiteral\n\n    // Environment references\n    | columnReference                                                                   #columnReferenceAlt\n\n    // Keep this at the bottom to use it the mechanism that query authors have to specify precedence.\n    | LPARENS expression RPARENS                                                        #parenthesizedExpression\n    ;\n\nhamelintype\n    : simpleIdentifier LPARENS hamelintype (COMMA hamelintype)* COMMA? RPARENS          #parameterizedType\n    | simpleIdentifier LPARENS INTEGER_VALUE (COMMA INTEGER_VALUE)* COMMA? RPARENS      #typeWithArguments\n    | LCURLY simpleIdentifier COLON hamelintype\n             (COMMA simpleIdentifier COLON hamelintype)* COMMA? RCURLY                  #structType\n    | LPARENS hamelintype (COMMA hamelintype )* COMMA? RPARENS                          #tupleType\n    | simpleIdentifier                                                                  #simpleType\n    ;\n\npattern\n    : fromClause quantifier?                                                            #quantified\n    | LPARENS pattern+ RPARENS quantifier                                               #nested\n    ;\n\nquantifier\n    : ASTERISK                                                                          #AnyNumber\n    | PLUS                                                                              #AtLeastOne\n    | QUESTIONMARK                                                                      #ZeroOrOne\n    | LCURLY INTEGER_VALUE RCURLY                                                       #Exactly\n    ;\n\ncolumnReference\n    : simpleIdentifier\n    ;\n\ntableReference\n    : identifier\n    ;\n\nidentifier\n    : simpleIdentifier\n    | simpleIdentifier (DOT simpleIdentifier)+\n    ;\n\nsimpleIdentifier\n    : IDENTIFIER                                                                        #unquotedIdentifier\n    | BACKQUOTED_IDENTIFIER                                                             #backQuotedIdentifier\n    ;\n\nstring\n    : SINGLE_QUOTED_STRING                                                              #basicSingleQuotedStringLiteral\n    | DOUBLE_QUOTED_STRING                                                              #basicDoubleQuotedStringLiteral\n    | value=SINGLE_QUOTED_UNICODE_STRING (UESCAPE uesc=SINGLE_QUOTED_STRING)?           #unicodeSingleQuotedStringLiteral\n    | value=DOUBLE_QUOTED_UNICODE_STRING (UESCAPE uesc=DOUBLE_QUOTED_STRING)?           #unicodeDoubleQuotedStringLiteral\n    ;\n\nnumber\n    : value=DECIMAL_VALUE                                                               #decimalLiteral\n    | value=DOUBLE_VALUE                                                                #scientificLiteral\n    | value=INTEGER_VALUE                                                               #integerLiteral\n    ;\n\npositionalArgument\n    : expression\n    ;\n\nnamedArgument\n    : simpleIdentifier ASSIGN expression\n    ;\n\n//\n// COMMANDS\n//\n\nLET_COMMAND: 'LET' | 'let';\nWHERE_COMMAND: 'WHERE' | 'where';\nSELECT_COMMAND: 'SELECT' | 'select';\nDROP_COMMAND: 'DROP' | 'drop';\nFROM_COMMAND: 'FROM' | 'from';\nUNION_COMMAND: 'UNION' | 'union';\nLIMIT_COMMAND: 'LIMIT' | 'limit';\nPARSE_COMMAND: 'PARSE' | 'parse';\nWITHIN_COMMAND: 'WITHIN' | 'within';\nAGG_COMMAND: 'AGG' | 'agg';\nWINDOW_COMMAND: 'WINDOW' | 'window';\nAPPEND_COMMAND: 'APPEND' | 'append';\nJOIN_COMMAND: 'JOIN' | 'join';\nLOOKUP_COMMAND: 'LOOKUP' | 'lookup';\nEXPLODE_COMMAND: 'EXPLODE' | 'explode';\nUNNEST_COMMAND: 'UNNEST' | 'unnest';\nNEST_COMMAND: 'NEST' | 'nest';\nROWS_COMMAND: 'ROWS' | 'rows';\nMATCH_COMMAND: 'MATCH' | 'match';\n\nAS: 'AS' | 'as';\nNODROP: 'NODROP' | 'nodrop';\n\n//\n// Operators\n//\n\nPLUS: '+';\nMINUS: '-';\nASTERISK: '*';\nSLASH: '/';\nPERCENT: '%';\nLCURLY: '{';\nRCURLY: '}';\nCOLON: ':';\nQUESTIONMARK: '?';\n\nEQ: '==';\nNEQ: '!=';\nLT: '<';\nLTE: '<=';\nGT: '>';\nGTE: '>=';\nRANGE: '..';\n\nASSIGN: '=';\n\n//\n// Keywords\n//\n\nAND: 'AND' | 'and';\nFALSE: 'FALSE' | 'false';\nIS: 'IS' | 'is';\nNOT: 'NOT' | 'not';\nISNOT: 'IS NOT' | 'is not';\nIN: 'IN' | 'in';\nNOTIN: 'NOT IN' | 'not in';\nNULL: 'NULL' | 'null';\nOR: 'OR' | 'or';\nTRUE: 'TRUE' | 'true';\nUESCAPE: 'UESCAPE' | 'uescape';\nWITH: 'WITH' | 'with';\nBY: 'BY' | 'by';\nSORT: 'SORT' | 'sort';\nASC: 'ASC' | 'asc';\nDESC: 'DESC' | 'desc';\nDISTINCT_BY: 'DISTINCT BY' | 'distinct by';\nON: 'ON' | 'on';\nWHEN: 'WHEN' | 'when';\n\n//\n// Symbols\n//\n\nCOMMA: ',';\nPIPE: '|';\nLPARENS: '(';\nRPARENS: ')';\nDOT: '.';\nLBRACKET: '[';\nRBRACKET: ']';\n\n//\n// Literals\n//\n\nSINGLE_QUOTED_STRING\n        : '\\'' ( ~'\\'' | '\\'\\'')* '\\''\n        ;\nDOUBLE_QUOTED_STRING\n        : '\"' ( ~'\"' | '\"\"')* '\"'\n        ;\n\nSINGLE_QUOTED_UNICODE_STRING\n        : 'U&\\'' ( ~'\\'' | '\\'\\'')* '\\''    // Unicode string with default escape character: U&'Hello winter \\2603 !'\n        ;\n\nDOUBLE_QUOTED_UNICODE_STRING\n        : 'U&\"' ( ~'\"' | '\"\"')* '\"'         // Unicode string with custom escape character: U&'Hello winter #2603 !' UESCAPE '#'\n        ;\n\n// Note: we allow any character inside the binary literal and validate\n// its a correct literal when the AST is being constructed. This\n// allows us to provide more meaningful error messages to the user\nBINARY_LITERAL\n    : 'x\\'' (~'\\'')* '\\''\n    ;\n\nNANOSECOND_INTERVAL\n    : DECIMAL_INTEGER 'ns'\n    ;\n\nMICROSECOND_INTERVAL\n    : DECIMAL_INTEGER 'us'\n    ;\n\nMILLISECOND_INTERVAL\n    : DECIMAL_INTEGER 'ms'\n    ;\n\nSECOND_INTERVAL\n    : DECIMAL_INTEGER  ('s' | 'sec' | 'secs' | 'second' | 'seconds')\n    ;\n\nMINUTE_INTERVAL\n    : DECIMAL_INTEGER  ('m' | 'min' | 'mins' | 'minute' | 'minutes')\n    ;\n\nHOUR_INTERVAL\n    : DECIMAL_INTEGER ('h' | 'hr' | 'hrs' | 'hour' | 'hours')\n    ;\n\nDAY_INTERVAL\n    : DECIMAL_INTEGER ('d' | 'day' | 'days')\n    ;\n\nWEEK_INTERVAL\n    : DECIMAL_INTEGER ('w' | 'week' | 'weeks')\n    ;\n\nMONTH_INTERVAL\n    : DECIMAL_INTEGER ('mon' | 'month' | 'months')\n    ;\n\nQUARTER_INTERVAL\n    : DECIMAL_INTEGER ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')\n    ;\n\nYEAR_INTERVAL\n    : DECIMAL_INTEGER ('y' | 'yr' | 'yrs' | 'year' | 'years')\n    ;\n\nROWS_LITERAL\n    : DECIMAL_INTEGER ('r' | 'row' | 'rows')\n    ;\n\nSECOND_TRUNC\n    : '@'  ('s' | 'sec' | 'secs' | 'second' | 'seconds')\n    ;\n\nMINUTE_TRUNC\n    : '@'  ('m' | 'min' | 'mins' | 'minute' | 'minutes')\n    ;\n\nHOUR_TRUNC\n    : '@' ('h' | 'hr' | 'hrs' | 'hour' | 'hours')\n    ;\n\nDAY_TRUNC\n    : '@' ('d' | 'day' | 'days')\n    ;\n\nWEEK_TRUNC\n    : '@' ('w' | 'week' | 'weeks')\n    ;\n\nMONTH_TRUNC\n    : '@' ('mon' | 'month' | 'months')\n    ;\n\nQUARTER_TRUNC\n    : '@' ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')\n    ;\n\nYEAR_TRUNC\n    : '@' ('y' | 'yr' | 'yrs' | 'year' | 'years')\n    ;\n\nINTEGER_VALUE\n    : DECIMAL_INTEGER\n    | HEXADECIMAL_INTEGER\n    | OCTAL_INTEGER\n    | BINARY_INTEGER\n    ;\n\nDECIMAL_VALUE\n    : DECIMAL_INTEGER '.' DECIMAL_INTEGER\n    | '.' DECIMAL_INTEGER\n    ;\n\nDOUBLE_VALUE\n    : DIGIT+ ('.' DIGIT*)? EXPONENT\n    | '.' DIGIT+ EXPONENT\n    ;\n\nIDENTIFIER\n    : [a-zA-Z_][a-zA-Z_0-9]*\n    ;\n\nBACKQUOTED_IDENTIFIER\n    : '`' ( ~'`' | '``' )* '`'\n    ;\n\nfragment DECIMAL_INTEGER\n    : DIGIT ('_'? DIGIT)*\n    ;\n\nfragment HEXADECIMAL_INTEGER\n    : '0x' ('_'? (DIGIT | [A-F]))+\n    ;\n\nfragment OCTAL_INTEGER\n    : '0o' ('_'? [0-7])+\n    ;\n\nfragment BINARY_INTEGER\n    : '0b' ('_'? [01])+\n    ;\n\nfragment EXPONENT\n    : 'e' [+-]? DIGIT+\n    ;\n\nfragment DIGIT\n    : [0-9]\n    ;\n\n//\n// Comments and whitespace\n//\n\nSIMPLE_COMMENT\n    : '//' ~[\\r\\n]* '\\r'? '\\n'? -> channel(HIDDEN)\n    ;\n\nBRACKETED_COMMENT\n    : '/*' .*? '*/' -> channel(HIDDEN)\n    ;\n\nWS\n    : [ \\r\\n\\t]+ -> skip\n    ;\n";
 
-interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly __wbg_catalogprovider_free: (a: number, b: number) => void;
-  readonly catalogprovider_try_from_catalog: (a: any) => [number, number, number];
-  readonly __wbg_compiler_free: (a: number, b: number) => void;
-  readonly compiler_new: () => number;
-  readonly compiler_get_function_descriptions: (a: number) => [number, number];
-  readonly compiler_set_catalog_provider: (a: number, b: number) => void;
-  readonly compiler_set_time_range: (a: number, b: number, c: number) => void;
-  readonly compiler_set_time_range_expression: (a: number, b: number, c: number) => any;
-  readonly compiler_compile_query: (a: number, b: number, c: number) => any;
-  readonly compiler_compile_query_at: (a: number, b: number, c: number, d: number) => any;
-  readonly compiler_get_statement_datasets: (a: number, b: number, c: number) => any;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-  readonly __wbindgen_exn_store: (a: number) => void;
-  readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_externrefs: WebAssembly.Table;
-  readonly __externref_table_dealloc: (a: number) => void;
-  readonly __externref_drop_slice: (a: number, b: number) => void;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_start: () => void;
-}
+declare const hamelinPrompt = "## Hamelin Instructions\n\nI am going to teach you a new query language, it\u2019s called Hamelin. Its main purpose is to support SIEM use-cases. In some ways, it is similar to SQL, PRQL, Elastic Query Language, Sumo Logic Query Language or Splunk Query Language, though it has some distinct properties. It\u2019s a pipe language, which processes data and allows to separate the operations using pipes. Throughout this guide, I will include some examples in <example></example> tags.\n\nHamelin query consists out of one or more operations separated by pipe (\"|\"). It is very important to memorize the commands, as each pipe operation must start with either of these. Following are the only commands supported:\n\n- `FROM` is the beginning of every Hamelin query. Every query must pull data from _somewhere._ One exception is that Hamelin can be used to calculate some expression value too, e.g. <example>LET x = 8 * 2</example>.\n- `SELECT` allows to specify which columns are selected: <example>SELECT <col1>, <col2>, <col3> = <val></example> drops all columns except columns 1 and 2, and also defines a 3rd column to a new, specific value. It\u2019s optional and by default, SELECT * is implied (which selects all columns).\n- `WHERE` filters the rows that flow through it based on applying a boolean condition to each of them.\n- `LET <col> = <val>` defines a new column value, or shadows an existing value.\n- `DROP <col1>, <col2>` removes col1 and col2 from the projection.\n- `WITH <tab1> = <operations>` associates the tab1 with specified operations (until two newlines are encountered) , so tab1 can be reused later\n- `AGG <function1, function2, ...> BY <column1, column2, ...>` aggregates and groups by the data accordingly\n- `WINDOW` applies aggregation or window functions over sliding windows of data.\n- `MATCH` correlates multiple event patterns together.\n- `SORT <columns> <optional order>` sorts the rows using specified criteria (and `ASC` or `DESC` order, `ASC` being default)\n- `LIMIT <limit>` limits the output rows\n\nIt is extremely important to start each pipe section using one of the commands and use pipe (\"|\") to separate further operations, e.g.\n<example>\nFROM example | WHERE name = \"John Smith\" | SELECT name, address\n</example>\n\nFor example, to select columns \"c1\" and \"c2\" from table \"A\", one needs to write:\n\n<example>\nFROM A\n| SELECT c1, c2\n</example>\n\nTo add a filter for \"c1=3\" condition:\n\n<example>\nFROM A\n| WHERE c1 == 3\n| SELECT c1, c2\n</example>\n\nTo select all data from table \"A\" and associate column \"v\" value multipled by 2 with new column \"x\"\"\n\n<example>\nFROM A\n| LET x = v*2\n</example>\n\nTo associate column c1 with new column x and remove c1 and c3, this can be used:\n\n<example>\nFROM A\n| LET x = c1\n| DROP c1, c3\n</example>\n\nIf only c1, c2 and c3 are present, the above can be rewritten using just `SELECT` :\n<example>\nFROM A\n| SELECT x = c1, c2\n</example>\n\n### Aggregations\n\nAggregations are extremely common in queries and Hamelin supports these via `AGG` keyword: `| AGG <aggregation1>, <aggregation2>, ... BY column1, column2, ...`\n\nThe \"BY ...\" part is optional. Any columns or operations not specified in the aggregation operation will be dropped.\nThe list of aggregations is optional as well. When not specifying it, the operation acts in a similar way as the DISTINCT operator in SQL.\n\nTo aggregate rows in table \"A\" using count and group by c1:\n\n<example>\nFROM A\n | AGG count = count() BY c1\n</example>\n\nTo get distinct c1 values in table \"A\" and ignore nulls:\n\n<example>\nFROM A\n | AGG BY c1\n | WHERE c1 IS NOT NULL\n</example>\n\nTo aggregate rows in table \"A\" using count, group by c1 and select 10 most common values:\n\n<example>\nFROM A\n | AGG count = count() BY c1\n | SORT count DESC\n | LIMIT 10\n</example>\n\nTo take max of column c1, avg of column c2 and count, grouped by c3 and order max(c1) and take top 10 results, this can be issued:\n\n<example>\nFROM A\n | AGG count = count(), max = max(c1), avg = avg(c2) BY c3\n | SORT max DESC\n | LIMIT 10\n</example>\n\nIt is also possible to associate the aggregate values with new column names:\n\n<example>\nFROM A\n | AGG count = count(), max_c1 = max(c1), avg_c2 = avg(c2) by c3\n | SORT max_c1 desc\n | LIMIT 10\n</example>\n\nVery important: remember that aggregation selects only columns (and aggregations) specified, everything else is dropped. If you want to filter and aggregate data, consider the right order. E.g. to filter cases where c1 > 500 and then get average value of c2, grouped by c3 from table tbl, sorted by c2, this is the correct order (WHERE before AGG):\n\n<example>\nFROM tbl\n| WHERE c1 > 500\n| AGG avg_c2 = avg(c2) BY c3\n| SORT avg_c2\n</example>\n\nOf course, there are also cases when WHERE is applied after aggregation. E.g. to get average of c1 and count, grouped by c3, only where count() > 10, this will be a correct query:\n\n<example>\nFROM tbl\n | AGG count = count(), avg_c1 = avg(c1) BY c3\n | WHERE count > 10\n</example>\n\n### Literals\n\nHamelin adopts most of SQL\u2019s conventions for the basic literal syntax and semantics. Integer, decimal, boolean, string literals, and NULL all behave as they do in SQL, and have equivalent syntax.\n\nIn addition, however, Hamelin adds:\n\n- Double-quoted strings, which allow for the use of single quotes in the string without needing escaping.\n- Support for multiline. (You can add literal newlines into a string.)\n\n### Identifiers\n\nThe identifier syntax is similar to how Trino SQL handles identifiers. They are ASCII letter sequences. These sequences can also start with an underscore `_` or contain an underscore. The sequences can also contain digits, but they cannot start with digits. For Hamelin, we want to follow along with the way string _literals_ are using double-quotes in many existing programming languages and therefore we want to stray from the SQL example, which requires the use of single-quotes `'` for strings. This means we do not want to support double-quoted identifiers. We instead support backtick-quoted identifiers: `identifier of life`.\n\nFollowing query retrieves data from test table and filters for two conditions, whether \"curry wurst\" column is equal to the string \"wiener schnitzel\" and \"1a_extra\" column is equal to the string 'mit \"pommes\"' (note the doublequote inside)\n\n<example>\nFROM _test\n| WHERE `curry wurst` == 'wiener schnitzel'\n    AND `1a_extra` == 'mit \"pommes\"'\n</example>\n\n### Types\n\nHamelin has the following primitive types:\n\n- `boolean`\n- `int` - an umbrella for all integer types of any bit length\n- `decimal(precision, scale)` - exact fixed point values with specified precision and scale (e.g. `100.5`)\n- `double` - floating point numbers with variable precision (e.g. `-9.87e2`)\n- `string` - a string of any length, defined as a literal with either single quotes. String literals can escape quotes of either type by doubling them. (e.g. `\"She said \"\"hello\"\"\"`, `'It''s raining`)\n- `binary` - translates to `varbinary` in SQL for handling binary data\n- `timestamp` - an umbrella for date, timestamp, and all their variants (precision and timezone)\n- `interval` - an exact time duration of seconds, minutes, hours, or days (e.g. `30s`, `14d`)\n- `calendar_interval` - a calendar based time duration of months, quarters, or years (e.g. `3mon`, `5y`)\n- `range` - a span between two values of any primitive type using the `..` operator, which is inclusive on both sides and can be unbounded in either direction (e.g. `ts('2024-01-15')..now()`, `1..10`, `yesterday()..`). This is primarily used for time ranges, but can be used for any sortable type.\n\nHamelin has four composite types: \n\n- A `struct` has a set of fields, each with name and schema. You can access its field `my_field` of `my_struct` by doing `my_struct.my_field`\n- A `map` has a set of key-value pairs with homogeneous types. You can access the value for key `my_key` in `my_map` by doing `my_map[\"my_key\"]`\n- An `array` is an ordered list of values with homogeneous types. You can access the value at index 5 in `my_array` my doing `my_array[5]`\n- A `variant` is essentially a representation of untyped JSON data. You can access fields of JSON objects with the struct syntax above and you can access items of JSON arrays with the array syntax above.\n\nHamelin types can be casted to one another with the `AS` operator\n\n- If the type cast fails, the expression returns `NULL`\n- Casting never happens implicitly, so to concatenate strings with other types you need to cast. Often parentheses are necessary to make sure to cast the right expression (e.g. `\"Today is \" + (now() AS string)`)\n- Casting is most often useful for casting `variant`s parsed from JSON into the expected composite type (e.g. `| LET parsed = parse_json(message) AS { user_id: string, email: string}`)\n\nAny field in Hamelin can also be `NULL`. There is no concept of a `NOT NULL` field. You can check for `NULL` values with `IS NULL` or `IS NOT NULL`.\n\n### Operators\n\nHamelin is designed to be very intentional to make interactive query authoring more fluent and ergonomic.\n\n- Boolean operators\n  - Negation: `NOT`\n  - Conjunction: `AND`\n  - Disjunction: `OR`\n- Identity: `IS` (only really used to test against `NULL`).\n- Arithmetic:\n  - Addition: `+`\n  - Subtraction: `-`\n  - Multiplication: `*`\n  - Division: `/`\n  - Modulo: `%`\n  - Negation: `-`\n- Comparison:\n  - Equality: `==`\n    - Note we use single-equals for _assignment_.\n  - Non-equality: `!=`\n  - Greater than: `>`\n  - Less than: `<`\n  - Greater or equal: `>=`\n  - Less or equal: `<=`\n  - Inclusion: `IN ['item1', 'item2', ...]` or `IN 1..10`\n- Concatenation: `+`\n  - For strings: `'one' + 'two'` is `onetwo`\n  - For arrays: `['one'] + ['two']` is `['one', 'two']`\n\n### Unioning multiple tables with FROM\n\nHamelin allows a shorthand in the `FROM` command that targets _many_ sources (by separating them with commas (the `,` character). In a system that offers search, authors often want to perform the same search (or filter) over the rows that come from many different places. This is most common in \"needle\" queries, where you\u2019re looking for something relatively rare in a bunch of different data sets. This is not a common pattern in structured querying, likely explaining why SQL makes this so hard, and why there is no direct translation of this form in SQL.\n\nFor example, where table A defines only `f1` and `f2`, and table B defines only `f2` and `f3`, following will work. It will select `f1` and `f2` from table A and `f2` and `f3` from table B, so the full set of fields in the output of the following example will be `f1`, `f2`, `f3`.\n\n<example>\nFROM A, B\n</example>\n\nYou can also alias the fields based on which table they came from if you need to determine which table a given `f2` value came from example. In the following example, the output fields would be a struct `a` with sub-fields `f1` and `f2` and a struct `b` with sub-fields `f2` and `f3`. You can reference the sub-fields later in the query with `a.f1`, `b.f2`, etc. In addition, the fields are all still usable at the top level.\n\n<example>\nFROM a = A, b = B\n</example>\n\nAliasing tables is also useful when aggregating multiple types of rows (often from `WITH` CTEs):\n\n<example>\nWITH network_connections = FROM simba.sysmon_events\n| WHERE winlog.event_id == '3'\n\nWITH suspicious_file_creation = FROM simba.sysmon_events\n| WHERE winlog.event_id == '11'\n\nFROM network_connections = network_connections, suspicious_file_creation = suspicious_file_creation\n| AGG network_connections_count = count(network_connections), suspicious_file_creation_count = count(suspicious_file_creation)\n  BY host.name\n</example>\n\n### Functions\n\nThe following functions are supported in expressions (within `LET`, `SELECT`, `WHERE`, etc.):\n\n- len(x[])\n- sum(x[])\n- avg(x[])\n- min(x[])\n- max(x[])\n- array_distinct(x[])\n- filter_null(x[])\n- slice(x[], start, end) - returns a slice of the array x from start to end (inclusive). Supports negative indices to count from the end of the array.\n- flatten(x[]) - flattens a nested array by one level.\n- all(x[])\n- any(x[])\n- len(x[])\n- abs(x)\n- cbrt(x)\n- ceil(x)\n- floor(x)\n- degrees(x)\n- e() - Euler's number\n- exp(x)\n- ln(x)\n- log(b, x)\n- log10(x)\n- log2(x)\n- pi()\n- pow(x,p)\n- power(x,p)\n- radians(x)\n- round(x)\n- round(x,d)\n- sign(x)\n- sqrt(x)\n- truncate(x) - Remove the fractional part of a number\n- width_bucket(x,bound1,bound2,n) - the bucket number for a value in a histogram with equal-width buckets\n- width_bucket(x, bins[]) - the bucket number for a value using explicitly defined bucket boundaries\n- if(condition, then, else) - Both `then` and `else` must have the same type\n- case(when_condition: then_condition, when_condition: then_expression, ...) - Evaluates multiple condition-value pairs in order and returns the value associated with the first condition that evaluates to true. Returns null if no conditions are true. Every `then` must have the same type. There is no `else` in this expression, but you can achieve the same results by having `true` in the final `then_expression` like `case(when_condition: then_condition, when_condition: then_expression, ..., true: else_expression)`.\n- regexp_count(str, pattern)\n- regexp_extract(str, pattern)\n- regexp_extract(str, pattern, group)\n- regexp_extract_all(str, pattern)\n- regexp_extract_all(str, pattern, group)\n- regexp_like(string, pattern)\n- regexp_position(string, pattern, start)\n- regexp_replace(string, pattern)\n- regexp_replace(string, pattern, replacement)\n- regexp_split(string, pattern)\n- split(str, separator)\n- array_join(x[], separator)\n- replace(str, str_to_remove)\n- starts_with(str, prefix)\n- ends_with(str, suffix)\n- contains(str, substring)\n- len(str)\n- lower(str)\n- upper(str)\n- parse_json(json_str) - Only takes a string, never pass a map or struct\n- to_json_string(json_variant) - Only takes a variant. To pass other types, cast to variant with `AS variant`\n- typeof(x)\n- coalesce(x[]) - returns the first non-null value from a list of expressions\n- first(x)\n- last(x)\n- now()\n- today()\n- yesterday()\n- tomorrow()\n- ts(str)\n- at_timezone(timestamp, timezone)\n- year(timestamp)\n- month(timestamp)\n- day(timestamp)\n- hour(timestamp)\n- minute(timestamp)\n- second(timestamp)\n- from_unixtime_micros(x) - returns timestamp\n- from_unixtime_millis(x) - returns timestamp\n- from_unixtime_nanos(x) - returns timestamp\n- from_unixtime_seconds(x) - returns timestamp\n- from_millis(x) - returns interval\n- from_nanos(x) - returns interval\n- to_unixtime(timestamp) - returns double in seconds since the Unix epoch\n- to_millis(interval)\n- to_nanos(interval)\n- map(keys, values)\n- map(elements)\n- map_keys(map)\n- map_values(map)\n- next(expression)\n- cidr_contains(cidr, ip)\n- is_ipv4(ip)\n- is_ipv6(ip)\n\nThe following functions are only available within an AGG or WINDOW command:\n\n- all(bool_expr) - returns true if bool_expr is true for all rows\n- any(bool_expr) - returns true if bool_expr is true for any row\n- any_value(x) - returns an arbitrary value from each group\n- approx_percentile(x, percentile)\n- array_agg(x)\n- avg(x)\n- count_distinct(x) - counts the number of distinct non-null values of x\n- approx_distinct(x) - same as count_distinct(x) but uses an approximation algorithm that is faster but less accurate\n- count_if(condition) - counts all rows where condition is true\n- count(expr) - counts all rows where expr is non-null\n- count() - counts all rows\n- map_agg(key, value)\n- max(x)\n- min(x)\n- multimap_agg(key, value)\n- stddev(x)\n- sum(x)\n\nThe following functions are only available within a WINDOW command:\n\n- first_value(expression)\n- last_value(expression)\n- nth_value(expression, n)\n- cume_dist() - the number of rows with values less than or equal to the current row's value, divided by the total number of rows in the partition\n- percent_rank() - the percentile rank of each row within the window partition\n- dense_rank() - the rank of each row within a window partition without gaps\n- lag(expression, offset, ignore_nulls) - the value of an expression from a previous row within the window\n- lead(expression, offset, ignore_nulls) - the value of an expression from a subsequent row within the window\n- rank() - the rank of each row within a window partition with gaps\n- row_number() - a sequential row number for each row within a window partition\n\n### Describing time ranges\n\nUse `<low>..<high>` to describe a time range. Drop either `low` or `high` from the expression to communicate that side being unbounded. Allow the use of interval values, like `WITHIN 1hr..`. This time range syntax is used in the `timeRange` input of tools such as `execute-hamelin-query` and `query-page-run-query` to filter the result set to only the rows that have a `timestamp` in that time range. The time range syntax can be used in various parts of a Hamelin query, such as the `WINDOW` command.\n\nThe `WITHIN` keyword is used to compare expressions to ranges. It can be used in three basic forms:\n\n- `| WHERE val WITHIN low..high` allows `WITHIN` to be used as a binary boolean operator to test any sortable value against a range. This can be used anywhere boolean expressions are needed.\n- `| WINDOW WITHIN low..high` defines the frame clause of a window expression, filtering only those rows which are within the interval defined in terms of the current (or output) row.\n\nWhenever providing timestamp literals, you must use a format of `('<TIMESTAMP>' AS timestamp)`. For example, to describe noon on March 1st, 2020, use `('2020-03-01 12:00' AS timestamp)`. To select all rows from table A with timestamp greater than March 1st, 2020 on noon, you can use:\n<example>\nFROM A\n| WHERE timestamp > ('2025-03-01 12:00' AS timestamp)\n</example>\n\nTo select rows from the last hour, use `timeRange`:\n\n<example>\n-1h..\n</example>\n\nTo select rows which were between two and one hour ago, use the `timeRange`:\n\n<example>\n-2h..-1h\n</example>\n\nTo select rows which occured during the past 7 days, use the `timeRange`:\n\n<example>\n-1w..\n</example>\n\nThe `@` operator can also be used on a timestamp to round timestamps down to the nearest unit (day, hour, etc.).\n\nTo select rows in the previous 5 calendar days (not including today), use the `timeRange`:\n\n<example>\n-5d@d..now()@d\n</example>\n\n### Windows\n\n- `WINDOW` is a command that behaves like a mix of `AGG` and `LET`. It has three optional arguments that come at the end, all of which define a window:\n  - `BY <column1, column2>` means everything in the let is partitioned by this. (e.g., `BY user` means compute the function in a user-relative window).\n  - `SORT <column1, column2, ...>` means everything in the let sorted by this. (e.g., `SORT timestamp`).\n  - `WITHIN <range>` means everything in the let uses this range as the frame. (e.g., `WITHIN -5m` means within a 5 minute sliding window).\n    - Here, within uses nearly the same semantics as the `WITHIN` command.\n    - We introduce a new row interval literal with the suffix `r` or `rows` or `row` for defining ranges over exact numbers of rows rather than over ranges of values.\n- All three are optional, but the presence of any means _every_ expression in the let is defined \"over\" this window.\n\nFor example, to do count in 5 minute windows in table tbl:\n\n<example>\nFROM tbl | WINDOW c = count() WITHIN -5m\n</example>\n\n#### Rate-Based Detection with WINDOW...WITHIN\n\nUse `WINDOW ... WITHIN` for sliding window aggregations to detect bursts or spikes of activity.\n\n**When to use:** Count/aggregate events within a moving time window (e.g., \"10+ failed logins in the last 5 minutes\")\n\n**Key characteristics:**\n- **Purpose**: Detect bursts/spikes of activity (rate-based detection)\n- **Syntax**: `WINDOW ... BY grouping_keys WITHIN -duration`\n- **Window moves with time**: Always looks at the most recent N minutes/hours\n- **Use cases**: Rate limiting, burst detection, threshold alerting, brute force attacks\n- **Duration format**: `-5min`, `-1h`, `-1d` (negative values look backward in time)\n\n**Example: Brute Force Detection**\n\n<example>\nFROM simba.okta_events\n| WHERE event.action == \"user.session.start\" AND event.outcome == \"failure\"\n| WINDOW\n    failed_login_count = count(),\n    unique_ips = array_agg(source.ip)\n  BY user.name\n  WITHIN -5min\n| WHERE failed_login_count >= 10\n| SELECT\n    timestamp,\n    user.name,\n    event.count = failed_login_count,\n    source.ip_count = unique_ips\n</example>\n\n**Common WINDOW patterns:**\n\n<example>\n// Count events in sliding window\nFROM dataset | WINDOW event_count = count() BY host WITHIN -10min\n</example>\n\n<example>\n// Conditional counting\nFROM dataset\n| WINDOW\n    malicious_count = count_if(is_malicious),\n    total_count = count()\n  BY user.name\n  WITHIN -30min\n</example>\n\n### Event Correlation with MATCH\n\nThe `MATCH` command enables powerful multi-stage detection by correlating different event patterns. This is essential for detecting attack chains and reducing false positives.\n\n**When to use MATCH:**\n- Detecting multi-stage attacks (initial access \u2192 execution \u2192 persistence)\n- Correlating different behavioral indicators\n- Building high-fidelity detections that require multiple suspicious events\n- Creating attack chain detections with context\n\n**MATCH Pattern Structure:**\n\n```hamelin\n// Step 1: Define individual event patterns as WITH clauses\nWITH pattern1 = FROM dataset\n| WHERE <specific conditions>\n| SELECT fields...\n\nWITH pattern2 = FROM dataset\n| WHERE <different conditions>\n| SELECT fields...\n\n// Step 2: Correlate patterns using MATCH (space-separated!)\nMATCH p1=pattern1? p2=pattern2?\nBY correlation_key  // e.g., host, user, session_id\n| LET indicator_count = (\n    if(p1 IS NOT NULL, 1, 0) +\n    if(p2 IS NOT NULL, 1, 0)\n) AS int\n| WHERE indicator_count >= 2  // Alert when 2+ patterns match\n\n// Step 3: Aggregate and enrich\n| AGG\n    timestamp = min(timestamp),\n    event.start = min(timestamp),\n    event.end = max(timestamp),\n    pattern1_event = array_agg(p1)[0],\n    pattern2_event = array_agg(p2)[0],\n    indicator_count = max(indicator_count)\n  BY match_number, correlation_key\n\n// Step 4: Apply time window constraint\n| WHERE event.end - event.start <= 10min\n\n// Step 5: Build output with risk scoring\n| LET risk_score = (\n    if(pattern1_event IS NOT NULL, 30, 0) +\n    if(pattern2_event IS NOT NULL, 30, 0)\n) AS int\n| SELECT timestamp, fields...\n```\n\n**Critical MATCH Syntax Rules:**\n- Pattern aliases are **space-separated**, NOT comma-separated: `MATCH a=query1? b=query2? c=query3?`\n- Use `?` quantifier to make patterns optional (allows partial matches)\n- The `BY` clause specifies the correlation key (what ties events together)\n- Access matched events in AGG using `array_agg(alias)[0]`\n- Time window filtering: `WHERE event.end - event.start <= duration`\n\n**Example: Multi-Stage Malware Detection**\n\n<example>\n// Define behavioral indicators\nWITH lnk_powershell = FROM simba.sysmon_events\n| WHERE event.code == \"1\"\n| LET parent_image = coalesce(winlog.event_data[\"ParentImage\"], '') AS string\n| LET image = coalesce(winlog.event_data[\"Image\"], '') AS string\n| LET cmd_line = coalesce(winlog.event_data[\"CommandLine\"], '') AS string\n| LET host = host.name AS string\n| WHERE regexp_like(lower(parent_image), '(?i).*\\\\\\\\explorer\\\\.exe')\n  AND regexp_like(lower(image), '(?i).*(powershell|pwsh)\\\\.exe')\n  AND regexp_like(cmd_line, '(?i).*(hidden|-enc|-encodedcommand).*')\n| SELECT timestamp, host, process_image = image, process_commandline = cmd_line\n\nWITH cloud_download = FROM simba.sysmon_events\n| WHERE event.code == \"1\"\n| LET image = coalesce(winlog.event_data[\"Image\"], '') AS string\n| LET cmd_line = coalesce(winlog.event_data[\"CommandLine\"], '') AS string\n| LET host = host.name AS string\n| WHERE regexp_like(lower(image), '(?i).*(powershell|pwsh)\\\\.exe')\n  AND regexp_like(cmd_line, '(?i).*(github\\\\.com|dropbox\\\\.com).*')\n  AND regexp_like(cmd_line, '(?i).*(downloadstring|invoke-webrequest).*')\n| SELECT timestamp, host, process_image = image, process_commandline = cmd_line\n\n// Correlate: alert when 2+ indicators on same host within 10 min\nMATCH lnk=lnk_powershell? dl=cloud_download?\nBY host\n| LET indicator_count = (\n    if(lnk IS NOT NULL, 1, 0) +\n    if(dl IS NOT NULL, 1, 0)\n) AS int\n| WHERE indicator_count >= 2\n| AGG\n    timestamp = min(timestamp),\n    event.start = min(timestamp),\n    event.end = max(timestamp),\n    lnk_event = array_agg(lnk)[0],\n    dl_event = array_agg(dl)[0],\n    indicator_count = max(indicator_count)\n  BY match_number, host\n| WHERE event.end - event.start <= 10min\n| LET risk_score = (\n    if(lnk_event IS NOT NULL, 40, 0) +\n    if(dl_event IS NOT NULL, 40, 0)\n) AS int\n| SELECT\n    timestamp,\n    event.start,\n    event.end,\n    host,\n    event.count = indicator_count,\n    event.risk_score = risk_score\n</example>\n\n### More valid examples\n\nTo find records in table foo where column c1 is greater than 42, one needs to write:\n\n<example>\nFROM foo | WHERE c1 > 42\n</example>\n\nTo take unique (distinct) tuples of hostname and dest_port in table1, you can use AGG without aggregation functions:\n<example>\nFROM table1 | AGG BY hostname, dest_port\n</example>\n\nTo get number of flows by protocol and destination_port, then select top 10 by count, one needs to write:\n<example>\nFROM flows\n| AGG count = count() BY protocol, destination_port\n| SORT count DESC\n| LIMIT 10\n</example>\n\n### Invalid usage examples\n\nHere are some examples how NOT TO USE Hamelin. It is important to memorize these bad examples and verify when producing a response to the prompt if the output is correct.\n\nFollowing bad query mistakenly uses ORDER BY rather than SORT:\n<bad_example>\nFROM flows\n| ORDER BY count() DESC\n</bad_example>\nAfter fixing:\n<example>\nFROM flows\n| SORT count() DESC\n</example>\n\nFollowing bad query uses aggregation for sorting, but it was already done\n<bad_example>\nFROM flows\n| AGG count() BY user_name\n| SORT count()\n</bad_example>\nAfter fixing:\n<example>\nFROM flows\n| AGG count = count() BY user_name\n| SORT count\n</example>\n\nFollowing bad query mistakenly uses a single equal sign for equality test:\n<bad_example>\nFROM flows\n| WHERE user = 'John Smith'\n</bad_example>\nAfter fixing:\n<example>\nFROM flows\n| WHERE user == 'John Smith'\n</example>\n\nFollowing bad query mistakenly uses a star character in count:\n<bad_example>\nFROM flows\n| AGG count = count(*) BY user\n</bad_example>\nAfter fixing:\n<example>\nFROM flows\n| AGG count = count() BY user\n</example>\n\nFollowing bad query is mixing two commands in one:\n<bad_example>\nFROM flows | SELECT dest_port, LET proto = 'tcp'\n</bad_example>\nAfter fixing:\n<example>\nFROM flows | SELECT dest_port | LET proto = 'tcp'\n</example>\n\nFollowing bad query is using incorrect AS operator\n<bad_example>\nFROM flows | AGG max(timestamp) AS max_timestamp\n</bad_example>\nAfter fixing:\n<example>\nFROM flows | AGG max_timestamp = max(timestamp)\n</example>\n\nThe following bad query uses the LIKE operator, which doesn't exist in Hamelin:\n<bad_example>\nFROM flows | WHERE proto LIKE 'http%'\n</bad_example>\nThree different options to fix:\n<example>\nFROM flows | WHERE starts_with(proto, 'http')\n</example>\n<example>\nFROM flows | WHERE contains(proto, 'http')\n</example>\n<example>\nFROM flows | WHERE regexp_like(proto, '^http')\n</example>\n\nAGG does not support the WITHIN clause. Use WINDOW for rate-based detection with sliding windows.\n<bad_example>\n| AGG count() BY host WITHIN -5min\n</bad_example>\nAfter fixing:\n<example>\n| WINDOW count() BY host WITHIN -5min\n</example>\n\nMATCH patterns must be space-separated, not comma-separated.\n<bad_example>\nMATCH a=query1?, b=query2?, c=query3?\n</bad_example>\nAfter fixing:\n<example>\nMATCH a=query1? b=query2? c=query3?\n</example>\n\n### Key differences from SQL\n\nHamelin is not SQL but a unique query language! Carefully note the Hamelin rules when drafting a new query.\n\n- The count function does not include a star. So it's `count()` and definitely NOT `count(*)`.\n- There is no `CASE`/`WHEN` operator in Hamelin, but its implemented as the `case(when_condition: then_condition, when_condition: then_expression, ...)`\n- There's no `LIKE` operator. Instead, use `contains` to do simple substring searching or `regexp_like` to check if a string matches a regex pattern.\n- String concatenation happens with `+` not `||`\n- Double equals `==` is required for equality comparison. Single equals `=` is only used for assignment.\n- `AS` is used for casting, never for assignment/aliasing.\n- `SORT`, not `ORDER BY`\n- There is no support for subqueries within expressions (`| WHERE name IN (FROM admins | SELECT name)` is not valid)\n\n\n### Summary\n\nLet me note a few important properties:\n\n- Aggregation, when used, must be done using `AGG` keyword. The `AGG` command completely redefines the field space so only fields used/defined in the command will be available downstream.\n- Grouping, when used, must be done within a window or aggregation, i.e. there is no separate GROUP BY operation, but there is \"AGG .... BY ....\"\n- Each query must start with `FROM <table>`, followed by other operations separated by pipe character (\"|\").\n- Very important, pipe character (\"|\") must be always used to separate each operation. For example, this is invalid: <bad_example>FROM tbl WHERE x > 5</bad_example>. Instead, it should be: <example> FROM tbl | WHERE x > 5</example>. It\u2019s extremely important, use pipe characters for separation!\n- The only valid operation names are FROM, SELECT, WHERE, DROP, LET, WITH, WINDOW, MATCH, SORT, LIMIT, AGG - each operation must start with one of these.\n- When the prompt contains a SQL query on the input, you must convert it into a Hamelin query!!!\n\n### Best Practices\n\n- Don't use `SORT` and `LIMIT` commands unless the specific situation requires them or the user asks for it specifically. If you're adding `| SORT timestamp DESC` to the end of the query, that's almost always wrong.\n- `SELECT` is useful to narrow the result set if the you and the user know exactly what you're looking for, but `SELECT` is not required and should be omitted for most queries.\n\n### Final Reminders\n\nNow you should understand how Hamelin operates and how to write queries. When providing Hamelin queries, make sure you take into account syntax requirements of Hamelin and do logical operators correctly. Ensure that the order of operations as logically described in the question is followed. Ensure that the order of aggregating and filtering operations is correct. When asked for providing a Hamelin query, provide concise output with a correct Hamelin query.\n";
 
-type SyncInitInput = BufferSource | WebAssembly.Module;
+type QuerySort = {
+    column: string;
+    direction: "asc" | "desc" | null;
+};
 /**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
-*
-* @returns {InitOutput}
-*/
-declare function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+ * Returns the top level sorting information from the provided Hamelin query.
+ */
+declare const getSorts: (hamelinQuery: string) => QuerySort[];
 
-declare const compileHamelin: (catalog: Catalog, hamelinInput: string, timeRange?: string) => Promise<CompileQueryResult>;
-declare const createCompiler: (catalog: Catalog) => Promise<Compiler>;
+type QueryAggregation = {
+    columns: string[];
+    by: string[];
+    sort: QuerySort[];
+};
+declare const getAggregations: (query: string) => QueryAggregation[];
 
-declare class HamelinLexer extends antlr.Lexer {
-    static readonly LET_COMMAND = 1;
-    static readonly WHERE_COMMAND = 2;
-    static readonly SELECT_COMMAND = 3;
-    static readonly DROP_COMMAND = 4;
-    static readonly FROM_COMMAND = 5;
-    static readonly UNION_COMMAND = 6;
-    static readonly LIMIT_COMMAND = 7;
-    static readonly PARSE_COMMAND = 8;
-    static readonly WITHIN_COMMAND = 9;
-    static readonly AGG_COMMAND = 10;
-    static readonly WINDOW_COMMAND = 11;
-    static readonly APPEND_COMMAND = 12;
-    static readonly JOIN_COMMAND = 13;
-    static readonly LOOKUP_COMMAND = 14;
-    static readonly EXPLODE_COMMAND = 15;
-    static readonly UNNEST_COMMAND = 16;
-    static readonly NEST_COMMAND = 17;
-    static readonly ROWS_COMMAND = 18;
-    static readonly MATCH_COMMAND = 19;
-    static readonly AS = 20;
-    static readonly NODROP = 21;
-    static readonly PLUS = 22;
-    static readonly MINUS = 23;
-    static readonly ASTERISK = 24;
-    static readonly SLASH = 25;
-    static readonly PERCENT = 26;
-    static readonly LCURLY = 27;
-    static readonly RCURLY = 28;
-    static readonly COLON = 29;
-    static readonly QUESTIONMARK = 30;
-    static readonly EQ = 31;
-    static readonly NEQ = 32;
-    static readonly LT = 33;
-    static readonly LTE = 34;
-    static readonly GT = 35;
-    static readonly GTE = 36;
-    static readonly RANGE = 37;
-    static readonly ASSIGN = 38;
-    static readonly AND = 39;
-    static readonly FALSE = 40;
-    static readonly IS = 41;
-    static readonly NOT = 42;
-    static readonly ISNOT = 43;
-    static readonly IN = 44;
-    static readonly NOTIN = 45;
-    static readonly NULL = 46;
-    static readonly OR = 47;
-    static readonly TRUE = 48;
-    static readonly UESCAPE = 49;
-    static readonly WITH = 50;
-    static readonly BY = 51;
-    static readonly SORT = 52;
-    static readonly ASC = 53;
-    static readonly DESC = 54;
-    static readonly DISTINCT_BY = 55;
-    static readonly ON = 56;
-    static readonly WHEN = 57;
-    static readonly COMMA = 58;
-    static readonly PIPE = 59;
-    static readonly LPARENS = 60;
-    static readonly RPARENS = 61;
-    static readonly DOT = 62;
-    static readonly LBRACKET = 63;
-    static readonly RBRACKET = 64;
-    static readonly SINGLE_QUOTED_STRING = 65;
-    static readonly DOUBLE_QUOTED_STRING = 66;
-    static readonly SINGLE_QUOTED_UNICODE_STRING = 67;
-    static readonly DOUBLE_QUOTED_UNICODE_STRING = 68;
-    static readonly BINARY_LITERAL = 69;
-    static readonly NANOSECOND_INTERVAL = 70;
-    static readonly MICROSECOND_INTERVAL = 71;
-    static readonly MILLISECOND_INTERVAL = 72;
-    static readonly SECOND_INTERVAL = 73;
-    static readonly MINUTE_INTERVAL = 74;
-    static readonly HOUR_INTERVAL = 75;
-    static readonly DAY_INTERVAL = 76;
-    static readonly WEEK_INTERVAL = 77;
-    static readonly MONTH_INTERVAL = 78;
-    static readonly QUARTER_INTERVAL = 79;
-    static readonly YEAR_INTERVAL = 80;
-    static readonly ROWS_LITERAL = 81;
-    static readonly SECOND_TRUNC = 82;
-    static readonly MINUTE_TRUNC = 83;
-    static readonly HOUR_TRUNC = 84;
-    static readonly DAY_TRUNC = 85;
-    static readonly WEEK_TRUNC = 86;
-    static readonly MONTH_TRUNC = 87;
-    static readonly QUARTER_TRUNC = 88;
-    static readonly YEAR_TRUNC = 89;
-    static readonly INTEGER_VALUE = 90;
-    static readonly DECIMAL_VALUE = 91;
-    static readonly DOUBLE_VALUE = 92;
-    static readonly IDENTIFIER = 93;
-    static readonly BACKQUOTED_IDENTIFIER = 94;
-    static readonly SIMPLE_COMMENT = 95;
-    static readonly BRACKETED_COMMENT = 96;
-    static readonly WS = 97;
-    static readonly channelNames: string[];
-    static readonly literalNames: (string | null)[];
-    static readonly symbolicNames: (string | null)[];
-    static readonly modeNames: string[];
-    static readonly ruleNames: string[];
-    constructor(input: antlr.CharStream);
-    get grammarFileName(): string;
-    get literalNames(): (string | null)[];
-    get symbolicNames(): (string | null)[];
-    get ruleNames(): string[];
-    get serializedATN(): number[];
-    get channelNames(): string[];
-    get modeNames(): string[];
-    static readonly _serializedATN: number[];
-    private static __ATN;
-    static get _ATN(): antlr.ATN;
-    private static readonly vocabulary;
-    get vocabulary(): antlr.Vocabulary;
-    private static readonly decisionsToDFA;
-}
+declare const getDatasetsFromQuery: (catalog: Catalog, hamelinInput: string) => Promise<QueryDatasetsResult>;
+
+declare const getFunctionDescriptions: () => Promise<FunctionDescription[]>;
+
+/**
+ * Returns the top level limit information from the provided Hamelin query.
+ */
+declare const getLimits: (hamelinQuery: string) => number[];
+
+type FieldNames = string[] | null;
+declare const getSelectedFields: (query: string) => FieldNames;
+
+declare function parseTokenValueClass(stream: {
+    string: string;
+    pos: number;
+    match: (text: string) => boolean | unknown[] | null;
+}, functions: FunctionDescription[]): string | null;
+
+declare const sampleCatalog: Catalog;
 
 /**
- * This interface defines a complete generic visitor for a parse tree produced
- * by `HamelinParser`.
+ * Invokes Antlr4-c3 to collect completion candidates for a given input string
+ * at a specific position.
  *
- * @param <Result> The return type of the visit operation. Use `void` for
- * operations with no return type.
+ * @param input The input string to analyze.
+ * @param pos Request completion at this index in the input string,
+ * @returns A collection of candidates or undefined if no candidates are found
+ *          or the position is invalid.
  */
-declare class HamelinVisitor<Result> extends AbstractParseTreeVisitor<Result> {
-    /**
-     * Visit a parse tree produced by `HamelinParser.identifierEOF`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitIdentifierEOF?: (ctx: IdentifierEOFContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.queryEOF`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitQueryEOF?: (ctx: QueryEOFContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.commandEOF`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitCommandEOF?: (ctx: CommandEOFContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.expressionEOF`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitExpressionEOF?: (ctx: ExpressionEOFContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.pipelineEOF`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitPipelineEOF?: (ctx: PipelineEOFContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.simpleIdentifierEOF`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitSimpleIdentifierEOF?: (ctx: SimpleIdentifierEOFContext) => Result;
-    /**
-     * Visit a parse tree produced by the `withQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitWithQuery?: (ctx: WithQueryContext) => Result;
-    /**
-     * Visit a parse tree produced by the `standaloneQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitStandaloneQuery?: (ctx: StandaloneQueryContext) => Result;
-    /**
-     * Visit a parse tree produced by the `expressionQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitExpressionQuery?: (ctx: ExpressionQueryContext) => Result;
-    /**
-     * Visit a parse tree produced by the `pipelineAlt`
-     * labeled alternative in `HamelinParser.pipeline`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitPipelineAlt?: (ctx: PipelineAltContext) => Result;
-    /**
-     * Visit a parse tree produced by the `letCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitLetCommand?: (ctx: LetCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `whereCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitWhereCommand?: (ctx: WhereCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `selectCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitSelectCommand?: (ctx: SelectCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `dropCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitDropCommand?: (ctx: DropCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `fromCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitFromCommand?: (ctx: FromCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unionCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnionCommand?: (ctx: UnionCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `limitCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitLimitCommand?: (ctx: LimitCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `parseCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitParseCommand?: (ctx: ParseCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `withinCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitWithinCommand?: (ctx: WithinCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `aggCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitAggCommand?: (ctx: AggCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `sortCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitSortCommand?: (ctx: SortCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `windowCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitWindowCommand?: (ctx: WindowCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `appendCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitAppendCommand?: (ctx: AppendCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `joinCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitJoinCommand?: (ctx: JoinCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `explodeCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitExplodeCommand?: (ctx: ExplodeCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unnestCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnnestCommand?: (ctx: UnnestCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `nestCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitNestCommand?: (ctx: NestCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by the `matchCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitMatchCommand?: (ctx: MatchCommandContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.assignmentClause`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitAssignmentClause?: (ctx: AssignmentClauseContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.groupClause`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitGroupClause?: (ctx: GroupClauseContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.assignment`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitAssignment?: (ctx: AssignmentContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.matchDefine`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitMatchDefine?: (ctx: MatchDefineContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.selection`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitSelection?: (ctx: SelectionContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.sortExpression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitSortExpression?: (ctx: SortExpressionContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.tableAlias`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitTableAlias?: (ctx: TableAliasContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.fromClause`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitFromClause?: (ctx: FromClauseContext) => Result;
-    /**
-     * Visit a parse tree produced by the `structLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitStructLiteral?: (ctx: StructLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `columnReferenceAlt`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitColumnReferenceAlt?: (ctx: ColumnReferenceAltContext) => Result;
-    /**
-     * Visit a parse tree produced by the `deref`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitDeref?: (ctx: DerefContext) => Result;
-    /**
-     * Visit a parse tree produced by the `nullLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitNullLiteral?: (ctx: NullLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `arrayLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitArrayLiteral?: (ctx: ArrayLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `pairLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitPairLiteral?: (ctx: PairLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `tsTrunc`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitTsTrunc?: (ctx: TsTruncContext) => Result;
-    /**
-     * Visit a parse tree produced by the `rowsLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitRowsLiteral?: (ctx: RowsLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `tsTruncTimestampLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitTsTruncTimestampLiteral?: (ctx: TsTruncTimestampLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unaryPrefixOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnaryPrefixOperator?: (ctx: UnaryPrefixOperatorContext) => Result;
-    /**
-     * Visit a parse tree produced by the `binaryLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitBinaryLiteral?: (ctx: BinaryLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `indexAccess`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitIndexAccess?: (ctx: IndexAccessContext) => Result;
-    /**
-     * Visit a parse tree produced by the `cast`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitCast?: (ctx: CastContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unaryPostfixOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnaryPostfixOperator?: (ctx: UnaryPostfixOperatorContext) => Result;
-    /**
-     * Visit a parse tree produced by the `tupleLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitTupleLiteral?: (ctx: TupleLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `parenthesizedExpression`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => Result;
-    /**
-     * Visit a parse tree produced by the `stringLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitStringLiteral?: (ctx: StringLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `binaryOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitBinaryOperator?: (ctx: BinaryOperatorContext) => Result;
-    /**
-     * Visit a parse tree produced by the `functionCall`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitFunctionCall?: (ctx: FunctionCallContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unboundRangeLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnboundRangeLiteral?: (ctx: UnboundRangeLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `numericLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitNumericLiteral?: (ctx: NumericLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `booleanLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitBooleanLiteral?: (ctx: BooleanLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `intervalLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitIntervalLiteral?: (ctx: IntervalLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `parameterizedType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitParameterizedType?: (ctx: ParameterizedTypeContext) => Result;
-    /**
-     * Visit a parse tree produced by the `typeWithArguments`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitTypeWithArguments?: (ctx: TypeWithArgumentsContext) => Result;
-    /**
-     * Visit a parse tree produced by the `structType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitStructType?: (ctx: StructTypeContext) => Result;
-    /**
-     * Visit a parse tree produced by the `tupleType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitTupleType?: (ctx: TupleTypeContext) => Result;
-    /**
-     * Visit a parse tree produced by the `simpleType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitSimpleType?: (ctx: SimpleTypeContext) => Result;
-    /**
-     * Visit a parse tree produced by the `quantified`
-     * labeled alternative in `HamelinParser.pattern`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitQuantified?: (ctx: QuantifiedContext) => Result;
-    /**
-     * Visit a parse tree produced by the `nested`
-     * labeled alternative in `HamelinParser.pattern`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitNested?: (ctx: NestedContext) => Result;
-    /**
-     * Visit a parse tree produced by the `AnyNumber`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitAnyNumber?: (ctx: AnyNumberContext) => Result;
-    /**
-     * Visit a parse tree produced by the `AtLeastOne`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitAtLeastOne?: (ctx: AtLeastOneContext) => Result;
-    /**
-     * Visit a parse tree produced by the `ZeroOrOne`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitZeroOrOne?: (ctx: ZeroOrOneContext) => Result;
-    /**
-     * Visit a parse tree produced by the `Exactly`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitExactly?: (ctx: ExactlyContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.columnReference`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitColumnReference?: (ctx: ColumnReferenceContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.tableReference`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitTableReference?: (ctx: TableReferenceContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.identifier`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitIdentifier?: (ctx: IdentifierContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unquotedIdentifier`
-     * labeled alternative in `HamelinParser.simpleIdentifier`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => Result;
-    /**
-     * Visit a parse tree produced by the `backQuotedIdentifier`
-     * labeled alternative in `HamelinParser.simpleIdentifier`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => Result;
-    /**
-     * Visit a parse tree produced by the `basicSingleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitBasicSingleQuotedStringLiteral?: (ctx: BasicSingleQuotedStringLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `basicDoubleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitBasicDoubleQuotedStringLiteral?: (ctx: BasicDoubleQuotedStringLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unicodeSingleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnicodeSingleQuotedStringLiteral?: (ctx: UnicodeSingleQuotedStringLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `unicodeDoubleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitUnicodeDoubleQuotedStringLiteral?: (ctx: UnicodeDoubleQuotedStringLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `decimalLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitDecimalLiteral?: (ctx: DecimalLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `scientificLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitScientificLiteral?: (ctx: ScientificLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by the `integerLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitIntegerLiteral?: (ctx: IntegerLiteralContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.positionalArgument`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitPositionalArgument?: (ctx: PositionalArgumentContext) => Result;
-    /**
-     * Visit a parse tree produced by `HamelinParser.namedArgument`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitNamedArgument?: (ctx: NamedArgumentContext) => Result;
-}
-
-declare class HamelinParser extends antlr.Parser {
-    static readonly LET_COMMAND = 1;
-    static readonly WHERE_COMMAND = 2;
-    static readonly SELECT_COMMAND = 3;
-    static readonly DROP_COMMAND = 4;
-    static readonly FROM_COMMAND = 5;
-    static readonly UNION_COMMAND = 6;
-    static readonly LIMIT_COMMAND = 7;
-    static readonly PARSE_COMMAND = 8;
-    static readonly WITHIN_COMMAND = 9;
-    static readonly AGG_COMMAND = 10;
-    static readonly WINDOW_COMMAND = 11;
-    static readonly APPEND_COMMAND = 12;
-    static readonly JOIN_COMMAND = 13;
-    static readonly LOOKUP_COMMAND = 14;
-    static readonly EXPLODE_COMMAND = 15;
-    static readonly UNNEST_COMMAND = 16;
-    static readonly NEST_COMMAND = 17;
-    static readonly ROWS_COMMAND = 18;
-    static readonly MATCH_COMMAND = 19;
-    static readonly AS = 20;
-    static readonly NODROP = 21;
-    static readonly PLUS = 22;
-    static readonly MINUS = 23;
-    static readonly ASTERISK = 24;
-    static readonly SLASH = 25;
-    static readonly PERCENT = 26;
-    static readonly LCURLY = 27;
-    static readonly RCURLY = 28;
-    static readonly COLON = 29;
-    static readonly QUESTIONMARK = 30;
-    static readonly EQ = 31;
-    static readonly NEQ = 32;
-    static readonly LT = 33;
-    static readonly LTE = 34;
-    static readonly GT = 35;
-    static readonly GTE = 36;
-    static readonly RANGE = 37;
-    static readonly ASSIGN = 38;
-    static readonly AND = 39;
-    static readonly FALSE = 40;
-    static readonly IS = 41;
-    static readonly NOT = 42;
-    static readonly ISNOT = 43;
-    static readonly IN = 44;
-    static readonly NOTIN = 45;
-    static readonly NULL = 46;
-    static readonly OR = 47;
-    static readonly TRUE = 48;
-    static readonly UESCAPE = 49;
-    static readonly WITH = 50;
-    static readonly BY = 51;
-    static readonly SORT = 52;
-    static readonly ASC = 53;
-    static readonly DESC = 54;
-    static readonly DISTINCT_BY = 55;
-    static readonly ON = 56;
-    static readonly WHEN = 57;
-    static readonly COMMA = 58;
-    static readonly PIPE = 59;
-    static readonly LPARENS = 60;
-    static readonly RPARENS = 61;
-    static readonly DOT = 62;
-    static readonly LBRACKET = 63;
-    static readonly RBRACKET = 64;
-    static readonly SINGLE_QUOTED_STRING = 65;
-    static readonly DOUBLE_QUOTED_STRING = 66;
-    static readonly SINGLE_QUOTED_UNICODE_STRING = 67;
-    static readonly DOUBLE_QUOTED_UNICODE_STRING = 68;
-    static readonly BINARY_LITERAL = 69;
-    static readonly NANOSECOND_INTERVAL = 70;
-    static readonly MICROSECOND_INTERVAL = 71;
-    static readonly MILLISECOND_INTERVAL = 72;
-    static readonly SECOND_INTERVAL = 73;
-    static readonly MINUTE_INTERVAL = 74;
-    static readonly HOUR_INTERVAL = 75;
-    static readonly DAY_INTERVAL = 76;
-    static readonly WEEK_INTERVAL = 77;
-    static readonly MONTH_INTERVAL = 78;
-    static readonly QUARTER_INTERVAL = 79;
-    static readonly YEAR_INTERVAL = 80;
-    static readonly ROWS_LITERAL = 81;
-    static readonly SECOND_TRUNC = 82;
-    static readonly MINUTE_TRUNC = 83;
-    static readonly HOUR_TRUNC = 84;
-    static readonly DAY_TRUNC = 85;
-    static readonly WEEK_TRUNC = 86;
-    static readonly MONTH_TRUNC = 87;
-    static readonly QUARTER_TRUNC = 88;
-    static readonly YEAR_TRUNC = 89;
-    static readonly INTEGER_VALUE = 90;
-    static readonly DECIMAL_VALUE = 91;
-    static readonly DOUBLE_VALUE = 92;
-    static readonly IDENTIFIER = 93;
-    static readonly BACKQUOTED_IDENTIFIER = 94;
-    static readonly SIMPLE_COMMENT = 95;
-    static readonly BRACKETED_COMMENT = 96;
-    static readonly WS = 97;
-    static readonly RULE_identifierEOF = 0;
-    static readonly RULE_queryEOF = 1;
-    static readonly RULE_commandEOF = 2;
-    static readonly RULE_expressionEOF = 3;
-    static readonly RULE_pipelineEOF = 4;
-    static readonly RULE_simpleIdentifierEOF = 5;
-    static readonly RULE_query = 6;
-    static readonly RULE_pipeline = 7;
-    static readonly RULE_command = 8;
-    static readonly RULE_assignmentClause = 9;
-    static readonly RULE_groupClause = 10;
-    static readonly RULE_assignment = 11;
-    static readonly RULE_matchDefine = 12;
-    static readonly RULE_selection = 13;
-    static readonly RULE_sortExpression = 14;
-    static readonly RULE_tableAlias = 15;
-    static readonly RULE_fromClause = 16;
-    static readonly RULE_expression = 17;
-    static readonly RULE_hamelintype = 18;
-    static readonly RULE_pattern = 19;
-    static readonly RULE_quantifier = 20;
-    static readonly RULE_columnReference = 21;
-    static readonly RULE_tableReference = 22;
-    static readonly RULE_identifier = 23;
-    static readonly RULE_simpleIdentifier = 24;
-    static readonly RULE_string = 25;
-    static readonly RULE_number = 26;
-    static readonly RULE_positionalArgument = 27;
-    static readonly RULE_namedArgument = 28;
-    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): antlr.FailedPredicateException;
-    constructor(input: antlr.TokenStream);
-    identifierEOF(): IdentifierEOFContext;
-    queryEOF(): QueryEOFContext;
-    commandEOF(): CommandEOFContext;
-    expressionEOF(): ExpressionEOFContext;
-    pipelineEOF(): PipelineEOFContext;
-    simpleIdentifierEOF(): SimpleIdentifierEOFContext;
-    query(): QueryContext;
-    pipeline(): PipelineContext;
-    command(): CommandContext;
-    assignmentClause(): AssignmentClauseContext;
-    groupClause(): GroupClauseContext;
-    assignment(): AssignmentContext;
-    matchDefine(): MatchDefineContext;
-    selection(): SelectionContext;
-    sortExpression(): SortExpressionContext;
-    tableAlias(): TableAliasContext;
-    fromClause(): FromClauseContext;
-    expression(): ExpressionContext;
-    expression(_p: number): ExpressionContext;
-    hamelintype(): HamelintypeContext;
-    pattern(): PatternContext;
-    quantifier(): QuantifierContext;
-    columnReference(): ColumnReferenceContext;
-    tableReference(): TableReferenceContext;
-    identifier(): IdentifierContext;
-    simpleIdentifier(): SimpleIdentifierContext;
-    string_(): StringContext;
-    number_(): NumberContext;
-    positionalArgument(): PositionalArgumentContext;
-    namedArgument(): NamedArgumentContext;
-    sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean;
-    private expression_sempred;
-    static readonly _serializedATN: number[];
-    private static __ATN;
-    static get _ATN(): antlr.ATN;
-    private static readonly vocabulary;
-    get vocabulary(): antlr.Vocabulary;
-    private static readonly decisionsToDFA;
-}
-declare class IdentifierEOFContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    identifier(): IdentifierContext;
-    EOF(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class QueryEOFContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    query(): QueryContext;
-    EOF(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class CommandEOFContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    command(): CommandContext;
-    EOF(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ExpressionEOFContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    expression(): ExpressionContext;
-    EOF(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class PipelineEOFContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    pipeline(): PipelineContext;
-    EOF(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class SimpleIdentifierEOFContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    simpleIdentifier(): SimpleIdentifierContext;
-    EOF(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class QueryContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: QueryContext): void;
-}
-declare class WithQueryContext extends QueryContext {
-    constructor(ctx: QueryContext);
-    pipeline(): PipelineContext[];
-    pipeline(i: number): PipelineContext | null;
-    WITH(): antlr.TerminalNode[];
-    WITH(i: number): antlr.TerminalNode | null;
-    simpleIdentifier(): SimpleIdentifierContext[];
-    simpleIdentifier(i: number): SimpleIdentifierContext | null;
-    ASSIGN(): antlr.TerminalNode[];
-    ASSIGN(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class StandaloneQueryContext extends QueryContext {
-    constructor(ctx: QueryContext);
-    pipeline(): PipelineContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ExpressionQueryContext extends QueryContext {
-    constructor(ctx: QueryContext);
-    expression(): ExpressionContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class PipelineContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: PipelineContext): void;
-}
-declare class PipelineAltContext extends PipelineContext {
-    constructor(ctx: PipelineContext);
-    command(): CommandContext[];
-    command(i: number): CommandContext | null;
-    PIPE(): antlr.TerminalNode[];
-    PIPE(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class CommandContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: CommandContext): void;
-}
-declare class WhereCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    WHERE_COMMAND(): antlr.TerminalNode;
-    expression(): ExpressionContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnnestCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    expression(): ExpressionContext;
-    UNNEST_COMMAND(): antlr.TerminalNode | null;
-    ROWS_COMMAND(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class DropCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    DROP_COMMAND(): antlr.TerminalNode;
-    selection(): SelectionContext[];
-    selection(i: number): SelectionContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class MatchCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    MATCH_COMMAND(): antlr.TerminalNode;
-    pattern(): PatternContext[];
-    pattern(i: number): PatternContext | null;
-    WHEN(): antlr.TerminalNode | null;
-    matchDefine(): MatchDefineContext[];
-    matchDefine(i: number): MatchDefineContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    BY(): antlr.TerminalNode[];
-    BY(i: number): antlr.TerminalNode | null;
-    groupClause(): GroupClauseContext[];
-    groupClause(i: number): GroupClauseContext | null;
-    SORT(): antlr.TerminalNode | null;
-    sortExpression(): SortExpressionContext[];
-    sortExpression(i: number): SortExpressionContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class SelectCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    SELECT_COMMAND(): antlr.TerminalNode;
-    assignmentClause(): AssignmentClauseContext[];
-    assignmentClause(i: number): AssignmentClauseContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class WindowCommandContext extends CommandContext {
-    _within?: ExpressionContext;
-    constructor(ctx: CommandContext);
-    WINDOW_COMMAND(): antlr.TerminalNode;
-    assignmentClause(): AssignmentClauseContext[];
-    assignmentClause(i: number): AssignmentClauseContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    BY(): antlr.TerminalNode[];
-    BY(i: number): antlr.TerminalNode | null;
-    groupClause(): GroupClauseContext[];
-    groupClause(i: number): GroupClauseContext | null;
-    SORT(): antlr.TerminalNode | null;
-    sortExpression(): SortExpressionContext[];
-    sortExpression(i: number): SortExpressionContext | null;
-    WITHIN_COMMAND(): antlr.TerminalNode | null;
-    expression(): ExpressionContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class LimitCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    LIMIT_COMMAND(): antlr.TerminalNode;
-    expression(): ExpressionContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class WithinCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    WITHIN_COMMAND(): antlr.TerminalNode;
-    expression(): ExpressionContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ExplodeCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    EXPLODE_COMMAND(): antlr.TerminalNode;
-    assignmentClause(): AssignmentClauseContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class AppendCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    APPEND_COMMAND(): antlr.TerminalNode;
-    tableReference(): TableReferenceContext;
-    DISTINCT_BY(): antlr.TerminalNode | null;
-    selection(): SelectionContext[];
-    selection(i: number): SelectionContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class NestCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    NEST_COMMAND(): antlr.TerminalNode;
-    identifier(): IdentifierContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class LetCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    LET_COMMAND(): antlr.TerminalNode;
-    assignment(): AssignmentContext[];
-    assignment(i: number): AssignmentContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class SortCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    SORT(): antlr.TerminalNode;
-    sortExpression(): SortExpressionContext[];
-    sortExpression(i: number): SortExpressionContext | null;
-    BY(): antlr.TerminalNode | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class JoinCommandContext extends CommandContext {
-    _on?: ExpressionContext;
-    constructor(ctx: CommandContext);
-    fromClause(): FromClauseContext;
-    JOIN_COMMAND(): antlr.TerminalNode | null;
-    LOOKUP_COMMAND(): antlr.TerminalNode | null;
-    ON(): antlr.TerminalNode | null;
-    expression(): ExpressionContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnionCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    UNION_COMMAND(): antlr.TerminalNode;
-    fromClause(): FromClauseContext[];
-    fromClause(i: number): FromClauseContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class AggCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    AGG_COMMAND(): antlr.TerminalNode;
-    assignmentClause(): AssignmentClauseContext[];
-    assignmentClause(i: number): AssignmentClauseContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    BY(): antlr.TerminalNode[];
-    BY(i: number): antlr.TerminalNode | null;
-    groupClause(): GroupClauseContext[];
-    groupClause(i: number): GroupClauseContext | null;
-    SORT(): antlr.TerminalNode | null;
-    sortExpression(): SortExpressionContext[];
-    sortExpression(i: number): SortExpressionContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class FromCommandContext extends CommandContext {
-    constructor(ctx: CommandContext);
-    FROM_COMMAND(): antlr.TerminalNode;
-    fromClause(): FromClauseContext[];
-    fromClause(i: number): FromClauseContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ParseCommandContext extends CommandContext {
-    _src?: ExpressionContext;
-    constructor(ctx: CommandContext);
-    PARSE_COMMAND(): antlr.TerminalNode;
-    string(): StringContext;
-    identifier(): IdentifierContext[];
-    identifier(i: number): IdentifierContext | null;
-    AS(): antlr.TerminalNode | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    NODROP(): antlr.TerminalNode | null;
-    expression(): ExpressionContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class AssignmentClauseContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    assignment(): AssignmentContext | null;
-    expression(): ExpressionContext | null;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class GroupClauseContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    assignmentClause(): AssignmentClauseContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class AssignmentContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    identifier(): IdentifierContext;
-    ASSIGN(): antlr.TerminalNode;
-    expression(): ExpressionContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class MatchDefineContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    simpleIdentifier(): SimpleIdentifierContext;
-    ASSIGN(): antlr.TerminalNode;
-    expression(): ExpressionContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class SelectionContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    identifier(): IdentifierContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class SortExpressionContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    expression(): ExpressionContext;
-    ASC(): antlr.TerminalNode | null;
-    DESC(): antlr.TerminalNode | null;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class TableAliasContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    simpleIdentifier(): SimpleIdentifierContext;
-    ASSIGN(): antlr.TerminalNode;
-    tableReference(): TableReferenceContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class FromClauseContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    tableAlias(): TableAliasContext | null;
-    tableReference(): TableReferenceContext | null;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ExpressionContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: ExpressionContext): void;
-}
-declare class StructLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    LCURLY(): antlr.TerminalNode;
-    simpleIdentifier(): SimpleIdentifierContext[];
-    simpleIdentifier(i: number): SimpleIdentifierContext | null;
-    COLON(): antlr.TerminalNode[];
-    COLON(i: number): antlr.TerminalNode | null;
-    expression(): ExpressionContext[];
-    expression(i: number): ExpressionContext | null;
-    RCURLY(): antlr.TerminalNode;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ColumnReferenceAltContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    columnReference(): ColumnReferenceContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class DerefContext extends ExpressionContext {
-    _left?: ExpressionContext;
-    _operator?: Token | null;
-    _right?: SimpleIdentifierContext;
-    constructor(ctx: ExpressionContext);
-    expression(): ExpressionContext;
-    DOT(): antlr.TerminalNode;
-    simpleIdentifier(): SimpleIdentifierContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class NullLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    NULL(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ArrayLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    LBRACKET(): antlr.TerminalNode;
-    RBRACKET(): antlr.TerminalNode;
-    expression(): ExpressionContext[];
-    expression(i: number): ExpressionContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class PairLiteralContext extends ExpressionContext {
-    _left?: ExpressionContext;
-    _operator?: Token | null;
-    _right?: ExpressionContext;
-    constructor(ctx: ExpressionContext);
-    expression(): ExpressionContext[];
-    expression(i: number): ExpressionContext | null;
-    COLON(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class TsTruncContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    expression(): ExpressionContext;
-    SECOND_TRUNC(): antlr.TerminalNode | null;
-    MINUTE_TRUNC(): antlr.TerminalNode | null;
-    HOUR_TRUNC(): antlr.TerminalNode | null;
-    DAY_TRUNC(): antlr.TerminalNode | null;
-    WEEK_TRUNC(): antlr.TerminalNode | null;
-    MONTH_TRUNC(): antlr.TerminalNode | null;
-    QUARTER_TRUNC(): antlr.TerminalNode | null;
-    YEAR_TRUNC(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class RowsLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    ROWS_LITERAL(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class TsTruncTimestampLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    SECOND_TRUNC(): antlr.TerminalNode | null;
-    MINUTE_TRUNC(): antlr.TerminalNode | null;
-    HOUR_TRUNC(): antlr.TerminalNode | null;
-    DAY_TRUNC(): antlr.TerminalNode | null;
-    WEEK_TRUNC(): antlr.TerminalNode | null;
-    MONTH_TRUNC(): antlr.TerminalNode | null;
-    QUARTER_TRUNC(): antlr.TerminalNode | null;
-    YEAR_TRUNC(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnaryPrefixOperatorContext extends ExpressionContext {
-    _operator?: Token | null;
-    constructor(ctx: ExpressionContext);
-    expression(): ExpressionContext;
-    MINUS(): antlr.TerminalNode | null;
-    PLUS(): antlr.TerminalNode | null;
-    RANGE(): antlr.TerminalNode | null;
-    NOT(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class BinaryLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    BINARY_LITERAL(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class IndexAccessContext extends ExpressionContext {
-    _value?: ExpressionContext;
-    _index?: ExpressionContext;
-    constructor(ctx: ExpressionContext);
-    LBRACKET(): antlr.TerminalNode;
-    RBRACKET(): antlr.TerminalNode;
-    expression(): ExpressionContext[];
-    expression(i: number): ExpressionContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class CastContext extends ExpressionContext {
-    _left?: ExpressionContext;
-    _operator?: Token | null;
-    _right?: HamelintypeContext;
-    constructor(ctx: ExpressionContext);
-    expression(): ExpressionContext;
-    AS(): antlr.TerminalNode;
-    hamelintype(): HamelintypeContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnaryPostfixOperatorContext extends ExpressionContext {
-    _operator?: Token | null;
-    constructor(ctx: ExpressionContext);
-    expression(): ExpressionContext;
-    RANGE(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class TupleLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    LPARENS(): antlr.TerminalNode;
-    RPARENS(): antlr.TerminalNode;
-    expression(): ExpressionContext[];
-    expression(i: number): ExpressionContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ParenthesizedExpressionContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    LPARENS(): antlr.TerminalNode;
-    expression(): ExpressionContext;
-    RPARENS(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class StringLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    string(): StringContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class BinaryOperatorContext extends ExpressionContext {
-    _left?: ExpressionContext;
-    _operator?: Token | null;
-    _right?: ExpressionContext;
-    constructor(ctx: ExpressionContext);
-    expression(): ExpressionContext[];
-    expression(i: number): ExpressionContext | null;
-    ASTERISK(): antlr.TerminalNode | null;
-    SLASH(): antlr.TerminalNode | null;
-    PERCENT(): antlr.TerminalNode | null;
-    PLUS(): antlr.TerminalNode | null;
-    MINUS(): antlr.TerminalNode | null;
-    RANGE(): antlr.TerminalNode | null;
-    EQ(): antlr.TerminalNode | null;
-    NEQ(): antlr.TerminalNode | null;
-    LT(): antlr.TerminalNode | null;
-    LTE(): antlr.TerminalNode | null;
-    GT(): antlr.TerminalNode | null;
-    GTE(): antlr.TerminalNode | null;
-    IS(): antlr.TerminalNode | null;
-    ISNOT(): antlr.TerminalNode | null;
-    IN(): antlr.TerminalNode | null;
-    NOTIN(): antlr.TerminalNode | null;
-    AND(): antlr.TerminalNode | null;
-    OR(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class FunctionCallContext extends ExpressionContext {
-    _functionName?: SimpleIdentifierContext;
-    constructor(ctx: ExpressionContext);
-    LPARENS(): antlr.TerminalNode;
-    RPARENS(): antlr.TerminalNode;
-    simpleIdentifier(): SimpleIdentifierContext;
-    namedArgument(): NamedArgumentContext[];
-    namedArgument(i: number): NamedArgumentContext | null;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    positionalArgument(): PositionalArgumentContext[];
-    positionalArgument(i: number): PositionalArgumentContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnboundRangeLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    RANGE(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class NumericLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    number(): NumberContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class BooleanLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    TRUE(): antlr.TerminalNode | null;
-    FALSE(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class IntervalLiteralContext extends ExpressionContext {
-    constructor(ctx: ExpressionContext);
-    NANOSECOND_INTERVAL(): antlr.TerminalNode | null;
-    MICROSECOND_INTERVAL(): antlr.TerminalNode | null;
-    MILLISECOND_INTERVAL(): antlr.TerminalNode | null;
-    SECOND_INTERVAL(): antlr.TerminalNode | null;
-    MINUTE_INTERVAL(): antlr.TerminalNode | null;
-    HOUR_INTERVAL(): antlr.TerminalNode | null;
-    DAY_INTERVAL(): antlr.TerminalNode | null;
-    WEEK_INTERVAL(): antlr.TerminalNode | null;
-    MONTH_INTERVAL(): antlr.TerminalNode | null;
-    QUARTER_INTERVAL(): antlr.TerminalNode | null;
-    YEAR_INTERVAL(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class HamelintypeContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: HamelintypeContext): void;
-}
-declare class SimpleTypeContext extends HamelintypeContext {
-    constructor(ctx: HamelintypeContext);
-    simpleIdentifier(): SimpleIdentifierContext;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class TypeWithArgumentsContext extends HamelintypeContext {
-    constructor(ctx: HamelintypeContext);
-    simpleIdentifier(): SimpleIdentifierContext;
-    LPARENS(): antlr.TerminalNode;
-    INTEGER_VALUE(): antlr.TerminalNode[];
-    INTEGER_VALUE(i: number): antlr.TerminalNode | null;
-    RPARENS(): antlr.TerminalNode;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class StructTypeContext extends HamelintypeContext {
-    constructor(ctx: HamelintypeContext);
-    LCURLY(): antlr.TerminalNode;
-    simpleIdentifier(): SimpleIdentifierContext[];
-    simpleIdentifier(i: number): SimpleIdentifierContext | null;
-    COLON(): antlr.TerminalNode[];
-    COLON(i: number): antlr.TerminalNode | null;
-    hamelintype(): HamelintypeContext[];
-    hamelintype(i: number): HamelintypeContext | null;
-    RCURLY(): antlr.TerminalNode;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class TupleTypeContext extends HamelintypeContext {
-    constructor(ctx: HamelintypeContext);
-    LPARENS(): antlr.TerminalNode;
-    hamelintype(): HamelintypeContext[];
-    hamelintype(i: number): HamelintypeContext | null;
-    RPARENS(): antlr.TerminalNode;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ParameterizedTypeContext extends HamelintypeContext {
-    constructor(ctx: HamelintypeContext);
-    simpleIdentifier(): SimpleIdentifierContext;
-    LPARENS(): antlr.TerminalNode;
-    hamelintype(): HamelintypeContext[];
-    hamelintype(i: number): HamelintypeContext | null;
-    RPARENS(): antlr.TerminalNode;
-    COMMA(): antlr.TerminalNode[];
-    COMMA(i: number): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class PatternContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: PatternContext): void;
-}
-declare class QuantifiedContext extends PatternContext {
-    constructor(ctx: PatternContext);
-    fromClause(): FromClauseContext;
-    quantifier(): QuantifierContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class NestedContext extends PatternContext {
-    constructor(ctx: PatternContext);
-    LPARENS(): antlr.TerminalNode;
-    RPARENS(): antlr.TerminalNode;
-    quantifier(): QuantifierContext;
-    pattern(): PatternContext[];
-    pattern(i: number): PatternContext | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class QuantifierContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: QuantifierContext): void;
-}
-declare class AnyNumberContext extends QuantifierContext {
-    constructor(ctx: QuantifierContext);
-    ASTERISK(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ExactlyContext extends QuantifierContext {
-    constructor(ctx: QuantifierContext);
-    LCURLY(): antlr.TerminalNode;
-    INTEGER_VALUE(): antlr.TerminalNode;
-    RCURLY(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class AtLeastOneContext extends QuantifierContext {
-    constructor(ctx: QuantifierContext);
-    PLUS(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ZeroOrOneContext extends QuantifierContext {
-    constructor(ctx: QuantifierContext);
-    QUESTIONMARK(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ColumnReferenceContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    simpleIdentifier(): SimpleIdentifierContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class TableReferenceContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    identifier(): IdentifierContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class IdentifierContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    simpleIdentifier(): SimpleIdentifierContext[];
-    simpleIdentifier(i: number): SimpleIdentifierContext | null;
-    DOT(): antlr.TerminalNode[];
-    DOT(i: number): antlr.TerminalNode | null;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class SimpleIdentifierContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: SimpleIdentifierContext): void;
-}
-declare class BackQuotedIdentifierContext extends SimpleIdentifierContext {
-    constructor(ctx: SimpleIdentifierContext);
-    BACKQUOTED_IDENTIFIER(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnquotedIdentifierContext extends SimpleIdentifierContext {
-    constructor(ctx: SimpleIdentifierContext);
-    IDENTIFIER(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class StringContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: StringContext): void;
-}
-declare class BasicDoubleQuotedStringLiteralContext extends StringContext {
-    constructor(ctx: StringContext);
-    DOUBLE_QUOTED_STRING(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnicodeSingleQuotedStringLiteralContext extends StringContext {
-    _value?: Token | null;
-    _uesc?: Token | null;
-    constructor(ctx: StringContext);
-    SINGLE_QUOTED_UNICODE_STRING(): antlr.TerminalNode;
-    UESCAPE(): antlr.TerminalNode | null;
-    SINGLE_QUOTED_STRING(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class BasicSingleQuotedStringLiteralContext extends StringContext {
-    constructor(ctx: StringContext);
-    SINGLE_QUOTED_STRING(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class UnicodeDoubleQuotedStringLiteralContext extends StringContext {
-    _value?: Token | null;
-    _uesc?: Token | null;
-    constructor(ctx: StringContext);
-    DOUBLE_QUOTED_UNICODE_STRING(): antlr.TerminalNode;
-    UESCAPE(): antlr.TerminalNode | null;
-    DOUBLE_QUOTED_STRING(): antlr.TerminalNode | null;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class NumberContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    get ruleIndex(): number;
-    copyFrom(ctx: NumberContext): void;
-}
-declare class DecimalLiteralContext extends NumberContext {
-    _value?: Token | null;
-    constructor(ctx: NumberContext);
-    DECIMAL_VALUE(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class ScientificLiteralContext extends NumberContext {
-    _value?: Token | null;
-    constructor(ctx: NumberContext);
-    DOUBLE_VALUE(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class IntegerLiteralContext extends NumberContext {
-    _value?: Token | null;
-    constructor(ctx: NumberContext);
-    INTEGER_VALUE(): antlr.TerminalNode;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class PositionalArgumentContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    expression(): ExpressionContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-declare class NamedArgumentContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    simpleIdentifier(): SimpleIdentifierContext;
-    ASSIGN(): antlr.TerminalNode;
-    expression(): ExpressionContext;
-    get ruleIndex(): number;
-    enterRule(listener: HamelinListener): void;
-    exitRule(listener: HamelinListener): void;
-    accept<Result>(visitor: HamelinVisitor<Result>): Result | null;
-}
-
-/**
- * This interface defines a complete listener for a parse tree produced by
- * `HamelinParser`.
- */
-declare class HamelinListener implements ParseTreeListener {
-    /**
-     * Enter a parse tree produced by `HamelinParser.identifierEOF`.
-     * @param ctx the parse tree
-     */
-    enterIdentifierEOF?: (ctx: IdentifierEOFContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.identifierEOF`.
-     * @param ctx the parse tree
-     */
-    exitIdentifierEOF?: (ctx: IdentifierEOFContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.queryEOF`.
-     * @param ctx the parse tree
-     */
-    enterQueryEOF?: (ctx: QueryEOFContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.queryEOF`.
-     * @param ctx the parse tree
-     */
-    exitQueryEOF?: (ctx: QueryEOFContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.commandEOF`.
-     * @param ctx the parse tree
-     */
-    enterCommandEOF?: (ctx: CommandEOFContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.commandEOF`.
-     * @param ctx the parse tree
-     */
-    exitCommandEOF?: (ctx: CommandEOFContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.expressionEOF`.
-     * @param ctx the parse tree
-     */
-    enterExpressionEOF?: (ctx: ExpressionEOFContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.expressionEOF`.
-     * @param ctx the parse tree
-     */
-    exitExpressionEOF?: (ctx: ExpressionEOFContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.pipelineEOF`.
-     * @param ctx the parse tree
-     */
-    enterPipelineEOF?: (ctx: PipelineEOFContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.pipelineEOF`.
-     * @param ctx the parse tree
-     */
-    exitPipelineEOF?: (ctx: PipelineEOFContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.simpleIdentifierEOF`.
-     * @param ctx the parse tree
-     */
-    enterSimpleIdentifierEOF?: (ctx: SimpleIdentifierEOFContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.simpleIdentifierEOF`.
-     * @param ctx the parse tree
-     */
-    exitSimpleIdentifierEOF?: (ctx: SimpleIdentifierEOFContext) => void;
-    /**
-     * Enter a parse tree produced by the `withQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     */
-    enterWithQuery?: (ctx: WithQueryContext) => void;
-    /**
-     * Exit a parse tree produced by the `withQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     */
-    exitWithQuery?: (ctx: WithQueryContext) => void;
-    /**
-     * Enter a parse tree produced by the `standaloneQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     */
-    enterStandaloneQuery?: (ctx: StandaloneQueryContext) => void;
-    /**
-     * Exit a parse tree produced by the `standaloneQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     */
-    exitStandaloneQuery?: (ctx: StandaloneQueryContext) => void;
-    /**
-     * Enter a parse tree produced by the `expressionQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     */
-    enterExpressionQuery?: (ctx: ExpressionQueryContext) => void;
-    /**
-     * Exit a parse tree produced by the `expressionQuery`
-     * labeled alternative in `HamelinParser.query`.
-     * @param ctx the parse tree
-     */
-    exitExpressionQuery?: (ctx: ExpressionQueryContext) => void;
-    /**
-     * Enter a parse tree produced by the `pipelineAlt`
-     * labeled alternative in `HamelinParser.pipeline`.
-     * @param ctx the parse tree
-     */
-    enterPipelineAlt?: (ctx: PipelineAltContext) => void;
-    /**
-     * Exit a parse tree produced by the `pipelineAlt`
-     * labeled alternative in `HamelinParser.pipeline`.
-     * @param ctx the parse tree
-     */
-    exitPipelineAlt?: (ctx: PipelineAltContext) => void;
-    /**
-     * Enter a parse tree produced by the `letCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterLetCommand?: (ctx: LetCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `letCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitLetCommand?: (ctx: LetCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `whereCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterWhereCommand?: (ctx: WhereCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `whereCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitWhereCommand?: (ctx: WhereCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `selectCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterSelectCommand?: (ctx: SelectCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `selectCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitSelectCommand?: (ctx: SelectCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `dropCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterDropCommand?: (ctx: DropCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `dropCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitDropCommand?: (ctx: DropCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `fromCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterFromCommand?: (ctx: FromCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `fromCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitFromCommand?: (ctx: FromCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `unionCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterUnionCommand?: (ctx: UnionCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `unionCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitUnionCommand?: (ctx: UnionCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `limitCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterLimitCommand?: (ctx: LimitCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `limitCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitLimitCommand?: (ctx: LimitCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `parseCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterParseCommand?: (ctx: ParseCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `parseCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitParseCommand?: (ctx: ParseCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `withinCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterWithinCommand?: (ctx: WithinCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `withinCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitWithinCommand?: (ctx: WithinCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `aggCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterAggCommand?: (ctx: AggCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `aggCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitAggCommand?: (ctx: AggCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `sortCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterSortCommand?: (ctx: SortCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `sortCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitSortCommand?: (ctx: SortCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `windowCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterWindowCommand?: (ctx: WindowCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `windowCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitWindowCommand?: (ctx: WindowCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `appendCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterAppendCommand?: (ctx: AppendCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `appendCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitAppendCommand?: (ctx: AppendCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `joinCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterJoinCommand?: (ctx: JoinCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `joinCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitJoinCommand?: (ctx: JoinCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `explodeCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterExplodeCommand?: (ctx: ExplodeCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `explodeCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitExplodeCommand?: (ctx: ExplodeCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `unnestCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterUnnestCommand?: (ctx: UnnestCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `unnestCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitUnnestCommand?: (ctx: UnnestCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `nestCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterNestCommand?: (ctx: NestCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `nestCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitNestCommand?: (ctx: NestCommandContext) => void;
-    /**
-     * Enter a parse tree produced by the `matchCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    enterMatchCommand?: (ctx: MatchCommandContext) => void;
-    /**
-     * Exit a parse tree produced by the `matchCommand`
-     * labeled alternative in `HamelinParser.command`.
-     * @param ctx the parse tree
-     */
-    exitMatchCommand?: (ctx: MatchCommandContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.assignmentClause`.
-     * @param ctx the parse tree
-     */
-    enterAssignmentClause?: (ctx: AssignmentClauseContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.assignmentClause`.
-     * @param ctx the parse tree
-     */
-    exitAssignmentClause?: (ctx: AssignmentClauseContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.groupClause`.
-     * @param ctx the parse tree
-     */
-    enterGroupClause?: (ctx: GroupClauseContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.groupClause`.
-     * @param ctx the parse tree
-     */
-    exitGroupClause?: (ctx: GroupClauseContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.assignment`.
-     * @param ctx the parse tree
-     */
-    enterAssignment?: (ctx: AssignmentContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.assignment`.
-     * @param ctx the parse tree
-     */
-    exitAssignment?: (ctx: AssignmentContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.matchDefine`.
-     * @param ctx the parse tree
-     */
-    enterMatchDefine?: (ctx: MatchDefineContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.matchDefine`.
-     * @param ctx the parse tree
-     */
-    exitMatchDefine?: (ctx: MatchDefineContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.selection`.
-     * @param ctx the parse tree
-     */
-    enterSelection?: (ctx: SelectionContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.selection`.
-     * @param ctx the parse tree
-     */
-    exitSelection?: (ctx: SelectionContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.sortExpression`.
-     * @param ctx the parse tree
-     */
-    enterSortExpression?: (ctx: SortExpressionContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.sortExpression`.
-     * @param ctx the parse tree
-     */
-    exitSortExpression?: (ctx: SortExpressionContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.tableAlias`.
-     * @param ctx the parse tree
-     */
-    enterTableAlias?: (ctx: TableAliasContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.tableAlias`.
-     * @param ctx the parse tree
-     */
-    exitTableAlias?: (ctx: TableAliasContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.fromClause`.
-     * @param ctx the parse tree
-     */
-    enterFromClause?: (ctx: FromClauseContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.fromClause`.
-     * @param ctx the parse tree
-     */
-    exitFromClause?: (ctx: FromClauseContext) => void;
-    /**
-     * Enter a parse tree produced by the `structLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterStructLiteral?: (ctx: StructLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `structLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitStructLiteral?: (ctx: StructLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `columnReferenceAlt`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterColumnReferenceAlt?: (ctx: ColumnReferenceAltContext) => void;
-    /**
-     * Exit a parse tree produced by the `columnReferenceAlt`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitColumnReferenceAlt?: (ctx: ColumnReferenceAltContext) => void;
-    /**
-     * Enter a parse tree produced by the `deref`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterDeref?: (ctx: DerefContext) => void;
-    /**
-     * Exit a parse tree produced by the `deref`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitDeref?: (ctx: DerefContext) => void;
-    /**
-     * Enter a parse tree produced by the `nullLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterNullLiteral?: (ctx: NullLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `nullLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitNullLiteral?: (ctx: NullLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `arrayLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterArrayLiteral?: (ctx: ArrayLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `arrayLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitArrayLiteral?: (ctx: ArrayLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `pairLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterPairLiteral?: (ctx: PairLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `pairLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitPairLiteral?: (ctx: PairLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `tsTrunc`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterTsTrunc?: (ctx: TsTruncContext) => void;
-    /**
-     * Exit a parse tree produced by the `tsTrunc`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitTsTrunc?: (ctx: TsTruncContext) => void;
-    /**
-     * Enter a parse tree produced by the `rowsLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterRowsLiteral?: (ctx: RowsLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `rowsLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitRowsLiteral?: (ctx: RowsLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `tsTruncTimestampLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterTsTruncTimestampLiteral?: (ctx: TsTruncTimestampLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `tsTruncTimestampLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitTsTruncTimestampLiteral?: (ctx: TsTruncTimestampLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `unaryPrefixOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterUnaryPrefixOperator?: (ctx: UnaryPrefixOperatorContext) => void;
-    /**
-     * Exit a parse tree produced by the `unaryPrefixOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitUnaryPrefixOperator?: (ctx: UnaryPrefixOperatorContext) => void;
-    /**
-     * Enter a parse tree produced by the `binaryLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterBinaryLiteral?: (ctx: BinaryLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `binaryLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitBinaryLiteral?: (ctx: BinaryLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `indexAccess`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterIndexAccess?: (ctx: IndexAccessContext) => void;
-    /**
-     * Exit a parse tree produced by the `indexAccess`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitIndexAccess?: (ctx: IndexAccessContext) => void;
-    /**
-     * Enter a parse tree produced by the `cast`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterCast?: (ctx: CastContext) => void;
-    /**
-     * Exit a parse tree produced by the `cast`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitCast?: (ctx: CastContext) => void;
-    /**
-     * Enter a parse tree produced by the `unaryPostfixOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterUnaryPostfixOperator?: (ctx: UnaryPostfixOperatorContext) => void;
-    /**
-     * Exit a parse tree produced by the `unaryPostfixOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitUnaryPostfixOperator?: (ctx: UnaryPostfixOperatorContext) => void;
-    /**
-     * Enter a parse tree produced by the `tupleLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterTupleLiteral?: (ctx: TupleLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `tupleLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitTupleLiteral?: (ctx: TupleLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `parenthesizedExpression`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => void;
-    /**
-     * Exit a parse tree produced by the `parenthesizedExpression`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => void;
-    /**
-     * Enter a parse tree produced by the `stringLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterStringLiteral?: (ctx: StringLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `stringLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitStringLiteral?: (ctx: StringLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `binaryOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterBinaryOperator?: (ctx: BinaryOperatorContext) => void;
-    /**
-     * Exit a parse tree produced by the `binaryOperator`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitBinaryOperator?: (ctx: BinaryOperatorContext) => void;
-    /**
-     * Enter a parse tree produced by the `functionCall`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterFunctionCall?: (ctx: FunctionCallContext) => void;
-    /**
-     * Exit a parse tree produced by the `functionCall`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitFunctionCall?: (ctx: FunctionCallContext) => void;
-    /**
-     * Enter a parse tree produced by the `unboundRangeLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterUnboundRangeLiteral?: (ctx: UnboundRangeLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `unboundRangeLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitUnboundRangeLiteral?: (ctx: UnboundRangeLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `numericLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterNumericLiteral?: (ctx: NumericLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `numericLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitNumericLiteral?: (ctx: NumericLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `booleanLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterBooleanLiteral?: (ctx: BooleanLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `booleanLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitBooleanLiteral?: (ctx: BooleanLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `intervalLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    enterIntervalLiteral?: (ctx: IntervalLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `intervalLiteral`
-     * labeled alternative in `HamelinParser.expression`.
-     * @param ctx the parse tree
-     */
-    exitIntervalLiteral?: (ctx: IntervalLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `parameterizedType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    enterParameterizedType?: (ctx: ParameterizedTypeContext) => void;
-    /**
-     * Exit a parse tree produced by the `parameterizedType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    exitParameterizedType?: (ctx: ParameterizedTypeContext) => void;
-    /**
-     * Enter a parse tree produced by the `typeWithArguments`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    enterTypeWithArguments?: (ctx: TypeWithArgumentsContext) => void;
-    /**
-     * Exit a parse tree produced by the `typeWithArguments`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    exitTypeWithArguments?: (ctx: TypeWithArgumentsContext) => void;
-    /**
-     * Enter a parse tree produced by the `structType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    enterStructType?: (ctx: StructTypeContext) => void;
-    /**
-     * Exit a parse tree produced by the `structType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    exitStructType?: (ctx: StructTypeContext) => void;
-    /**
-     * Enter a parse tree produced by the `tupleType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    enterTupleType?: (ctx: TupleTypeContext) => void;
-    /**
-     * Exit a parse tree produced by the `tupleType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    exitTupleType?: (ctx: TupleTypeContext) => void;
-    /**
-     * Enter a parse tree produced by the `simpleType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    enterSimpleType?: (ctx: SimpleTypeContext) => void;
-    /**
-     * Exit a parse tree produced by the `simpleType`
-     * labeled alternative in `HamelinParser.hamelintype`.
-     * @param ctx the parse tree
-     */
-    exitSimpleType?: (ctx: SimpleTypeContext) => void;
-    /**
-     * Enter a parse tree produced by the `quantified`
-     * labeled alternative in `HamelinParser.pattern`.
-     * @param ctx the parse tree
-     */
-    enterQuantified?: (ctx: QuantifiedContext) => void;
-    /**
-     * Exit a parse tree produced by the `quantified`
-     * labeled alternative in `HamelinParser.pattern`.
-     * @param ctx the parse tree
-     */
-    exitQuantified?: (ctx: QuantifiedContext) => void;
-    /**
-     * Enter a parse tree produced by the `nested`
-     * labeled alternative in `HamelinParser.pattern`.
-     * @param ctx the parse tree
-     */
-    enterNested?: (ctx: NestedContext) => void;
-    /**
-     * Exit a parse tree produced by the `nested`
-     * labeled alternative in `HamelinParser.pattern`.
-     * @param ctx the parse tree
-     */
-    exitNested?: (ctx: NestedContext) => void;
-    /**
-     * Enter a parse tree produced by the `AnyNumber`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    enterAnyNumber?: (ctx: AnyNumberContext) => void;
-    /**
-     * Exit a parse tree produced by the `AnyNumber`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    exitAnyNumber?: (ctx: AnyNumberContext) => void;
-    /**
-     * Enter a parse tree produced by the `AtLeastOne`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    enterAtLeastOne?: (ctx: AtLeastOneContext) => void;
-    /**
-     * Exit a parse tree produced by the `AtLeastOne`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    exitAtLeastOne?: (ctx: AtLeastOneContext) => void;
-    /**
-     * Enter a parse tree produced by the `ZeroOrOne`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    enterZeroOrOne?: (ctx: ZeroOrOneContext) => void;
-    /**
-     * Exit a parse tree produced by the `ZeroOrOne`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    exitZeroOrOne?: (ctx: ZeroOrOneContext) => void;
-    /**
-     * Enter a parse tree produced by the `Exactly`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    enterExactly?: (ctx: ExactlyContext) => void;
-    /**
-     * Exit a parse tree produced by the `Exactly`
-     * labeled alternative in `HamelinParser.quantifier`.
-     * @param ctx the parse tree
-     */
-    exitExactly?: (ctx: ExactlyContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.columnReference`.
-     * @param ctx the parse tree
-     */
-    enterColumnReference?: (ctx: ColumnReferenceContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.columnReference`.
-     * @param ctx the parse tree
-     */
-    exitColumnReference?: (ctx: ColumnReferenceContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.tableReference`.
-     * @param ctx the parse tree
-     */
-    enterTableReference?: (ctx: TableReferenceContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.tableReference`.
-     * @param ctx the parse tree
-     */
-    exitTableReference?: (ctx: TableReferenceContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.identifier`.
-     * @param ctx the parse tree
-     */
-    enterIdentifier?: (ctx: IdentifierContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.identifier`.
-     * @param ctx the parse tree
-     */
-    exitIdentifier?: (ctx: IdentifierContext) => void;
-    /**
-     * Enter a parse tree produced by the `unquotedIdentifier`
-     * labeled alternative in `HamelinParser.simpleIdentifier`.
-     * @param ctx the parse tree
-     */
-    enterUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => void;
-    /**
-     * Exit a parse tree produced by the `unquotedIdentifier`
-     * labeled alternative in `HamelinParser.simpleIdentifier`.
-     * @param ctx the parse tree
-     */
-    exitUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => void;
-    /**
-     * Enter a parse tree produced by the `backQuotedIdentifier`
-     * labeled alternative in `HamelinParser.simpleIdentifier`.
-     * @param ctx the parse tree
-     */
-    enterBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => void;
-    /**
-     * Exit a parse tree produced by the `backQuotedIdentifier`
-     * labeled alternative in `HamelinParser.simpleIdentifier`.
-     * @param ctx the parse tree
-     */
-    exitBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => void;
-    /**
-     * Enter a parse tree produced by the `basicSingleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    enterBasicSingleQuotedStringLiteral?: (ctx: BasicSingleQuotedStringLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `basicSingleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    exitBasicSingleQuotedStringLiteral?: (ctx: BasicSingleQuotedStringLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `basicDoubleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    enterBasicDoubleQuotedStringLiteral?: (ctx: BasicDoubleQuotedStringLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `basicDoubleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    exitBasicDoubleQuotedStringLiteral?: (ctx: BasicDoubleQuotedStringLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `unicodeSingleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    enterUnicodeSingleQuotedStringLiteral?: (ctx: UnicodeSingleQuotedStringLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `unicodeSingleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    exitUnicodeSingleQuotedStringLiteral?: (ctx: UnicodeSingleQuotedStringLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `unicodeDoubleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    enterUnicodeDoubleQuotedStringLiteral?: (ctx: UnicodeDoubleQuotedStringLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `unicodeDoubleQuotedStringLiteral`
-     * labeled alternative in `HamelinParser.string`.
-     * @param ctx the parse tree
-     */
-    exitUnicodeDoubleQuotedStringLiteral?: (ctx: UnicodeDoubleQuotedStringLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `decimalLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     */
-    enterDecimalLiteral?: (ctx: DecimalLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `decimalLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     */
-    exitDecimalLiteral?: (ctx: DecimalLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `scientificLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     */
-    enterScientificLiteral?: (ctx: ScientificLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `scientificLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     */
-    exitScientificLiteral?: (ctx: ScientificLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by the `integerLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     */
-    enterIntegerLiteral?: (ctx: IntegerLiteralContext) => void;
-    /**
-     * Exit a parse tree produced by the `integerLiteral`
-     * labeled alternative in `HamelinParser.number`.
-     * @param ctx the parse tree
-     */
-    exitIntegerLiteral?: (ctx: IntegerLiteralContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.positionalArgument`.
-     * @param ctx the parse tree
-     */
-    enterPositionalArgument?: (ctx: PositionalArgumentContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.positionalArgument`.
-     * @param ctx the parse tree
-     */
-    exitPositionalArgument?: (ctx: PositionalArgumentContext) => void;
-    /**
-     * Enter a parse tree produced by `HamelinParser.namedArgument`.
-     * @param ctx the parse tree
-     */
-    enterNamedArgument?: (ctx: NamedArgumentContext) => void;
-    /**
-     * Exit a parse tree produced by `HamelinParser.namedArgument`.
-     * @param ctx the parse tree
-     */
-    exitNamedArgument?: (ctx: NamedArgumentContext) => void;
-    visitTerminal(node: TerminalNode): void;
-    visitErrorNode(node: ErrorNode): void;
-    enterEveryRule(node: ParserRuleContext): void;
-    exitEveryRule(node: ParserRuleContext): void;
-}
-
-declare const hamelinGrammar = "grammar Hamelin;\n\nidentifierEOF\n    : identifier EOF\n    ;\n\nqueryEOF\n    : query EOF\n    ;\n\ncommandEOF\n    : command EOF\n    ;\n\nexpressionEOF\n    : expression EOF\n    ;\n\npipelineEOF\n    : pipeline EOF\n    ;\n\nsimpleIdentifierEOF\n    : simpleIdentifier EOF\n    ;\n\nquery\n    : (WITH simpleIdentifier ASSIGN pipeline)+ pipeline                                 #withQuery\n    | pipeline                                                                          #standaloneQuery\n    | expression                                                                        #expressionQuery\n    ;\n\npipeline\n    : command ( PIPE command )*                                                         #pipelineAlt\n    ;\n\ncommand\n    : LET_COMMAND assignment (COMMA assignment)* COMMA?                                 #letCommand\n    | WHERE_COMMAND expression                                                          #whereCommand\n    | SELECT_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?                  #selectCommand\n    | DROP_COMMAND selection (COMMA selection)* COMMA?                                  #dropCommand\n    | FROM_COMMAND fromClause (COMMA fromClause)* COMMA?                                #fromCommand\n    | UNION_COMMAND fromClause (COMMA fromClause)* COMMA?                               #unionCommand\n    | LIMIT_COMMAND expression                                                          #limitCommand\n    | PARSE_COMMAND src=expression? string\n                    AS? identifier (COMMA identifier)* COMMA? NODROP?                   #parseCommand\n    | WITHIN_COMMAND expression                                                         #withinCommand\n    | AGG_COMMAND (assignmentClause (COMMA assignmentClause)*)? COMMA?\n                  (BY groupClause (COMMA groupClause)*)? COMMA?\n                  (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?             #aggCommand\n    | SORT BY? sortExpression (COMMA sortExpression)* COMMA?                            #sortCommand\n    | WINDOW_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?\n                     (BY groupClause (COMMA groupClause)*)? COMMA?\n                     (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?\n                     (WITHIN_COMMAND within=expression)?                                #windowCommand\n    | APPEND_COMMAND tableReference (DISTINCT_BY selection (COMMA selection)*)? COMMA?  #appendCommand\n    | (JOIN_COMMAND | LOOKUP_COMMAND) fromClause (ON on=expression)?                    #joinCommand\n    | EXPLODE_COMMAND assignmentClause                                                  #explodeCommand\n    | (UNNEST_COMMAND | ROWS_COMMAND) expression                                        #unnestCommand\n    | NEST_COMMAND identifier                                                           #nestCommand\n    | MATCH_COMMAND pattern+\n                    (WHEN matchDefine (COMMA matchDefine)*)? COMMA?\n                    (BY groupClause (COMMA groupClause)*)? COMMA?\n                    (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?           #matchCommand\n    ;\n\nassignmentClause: assignment | expression;\ngroupClause: assignmentClause;\nassignment: identifier ASSIGN expression;\nmatchDefine: simpleIdentifier ASSIGN expression;\nselection: identifier;\nsortExpression: expression (ASC | DESC)?;\ntableAlias: simpleIdentifier ASSIGN tableReference;\nfromClause: tableAlias | tableReference;\n\nexpression\n    // Keep this list in precedence order (important!)\n    : operator=(MINUS | PLUS) expression                                                #unaryPrefixOperator\n    | expression (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |\n                  MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                             #tsTrunc\n    | left=expression operator=DOT right=simpleIdentifier                               #deref\n    | value=expression LBRACKET index=expression RBRACKET                               #indexAccess\n    | left=expression operator=(ASTERISK | SLASH | PERCENT) right=expression            #binaryOperator\n    | left=expression operator=(PLUS | MINUS) right=expression                          #binaryOperator\n    | operator=RANGE expression                                                         #unaryPrefixOperator\n    | expression operator=RANGE                                                         #unaryPostfixOperator\n    | left=expression operator=RANGE right=expression                                   #binaryOperator\n    | left=expression operator=AS right=hamelintype                                     #cast\n    | left=expression\n        operator=(EQ | NEQ | LT | LTE | GT | GTE | IS | ISNOT | IN | NOTIN)\n        right=expression                                                                #binaryOperator\n    | operator=NOT expression                                                           #unaryPrefixOperator\n    | left=expression operator=AND right=expression                                     #binaryOperator\n    | left=expression operator=OR right=expression                                      #binaryOperator\n\n    // Complex Literals\n    | left=expression operator=COLON right=expression                                   #pairLiteral\n    | LCURLY simpleIdentifier COLON expression\n      (COMMA simpleIdentifier COLON expression)* COMMA? RCURLY                          #structLiteral\n    | LPARENS ((expression COMMA) |\n               (expression COMMA expression (COMMA expression)* COMMA?)) RPARENS        #tupleLiteral\n    | LBRACKET (expression (COMMA expression)* COMMA?)? RBRACKET                        #arrayLiteral\n\n    // Function Calls\n    | functionName=simpleIdentifier\n        LPARENS (namedArgument (COMMA namedArgument)* COMMA?)? RPARENS                  #functionCall\n    | functionName=simpleIdentifier LPARENS\n        positionalArgument (COMMA positionalArgument)*\n                           (COMMA namedArgument)* COMMA? RPARENS                        #functionCall\n\n    // Primitive Literals\n    | NULL                                                                              #nullLiteral\n    | number                                                                            #numericLiteral\n    | TRUE                                                                              #booleanLiteral\n    | FALSE                                                                             #booleanLiteral\n    | string                                                                            #stringLiteral\n    | BINARY_LITERAL                                                                    #binaryLiteral\n    | RANGE                                                                             #unboundRangeLiteral\n    | (NANOSECOND_INTERVAL | MICROSECOND_INTERVAL | MILLISECOND_INTERVAL |\n       SECOND_INTERVAL | MINUTE_INTERVAL | HOUR_INTERVAL | DAY_INTERVAL |\n       WEEK_INTERVAL | MONTH_INTERVAL | QUARTER_INTERVAL | YEAR_INTERVAL)               #intervalLiteral\n    | ROWS_LITERAL                                                                      #rowsLiteral\n    | (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |\n       MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                                        #tsTruncTimestampLiteral\n\n    // Environment references\n    | columnReference                                                                   #columnReferenceAlt\n\n    // Keep this at the bottom to use it the mechanism that query authors have to specify precedence.\n    | LPARENS expression RPARENS                                                        #parenthesizedExpression\n    ;\n\nhamelintype\n    : simpleIdentifier LPARENS hamelintype (COMMA hamelintype)* COMMA? RPARENS          #parameterizedType\n    | simpleIdentifier LPARENS INTEGER_VALUE (COMMA INTEGER_VALUE)* COMMA? RPARENS      #typeWithArguments\n    | LCURLY simpleIdentifier COLON hamelintype\n             (COMMA simpleIdentifier COLON hamelintype)* COMMA? RCURLY                  #structType\n    | LPARENS hamelintype (COMMA hamelintype )* COMMA? RPARENS                          #tupleType\n    | simpleIdentifier                                                                  #simpleType\n    ;\n\npattern\n    : fromClause quantifier?                                                            #quantified\n    | LPARENS pattern+ RPARENS quantifier                                               #nested\n    ;\n\nquantifier\n    : ASTERISK                                                                          #AnyNumber\n    | PLUS                                                                              #AtLeastOne\n    | QUESTIONMARK                                                                      #ZeroOrOne\n    | LCURLY INTEGER_VALUE RCURLY                                                       #Exactly\n    ;\n\ncolumnReference\n    : simpleIdentifier\n    ;\n\ntableReference\n    : identifier\n    ;\n\nidentifier\n    : simpleIdentifier\n    | simpleIdentifier (DOT simpleIdentifier)+\n    ;\n\nsimpleIdentifier\n    : IDENTIFIER                                                                        #unquotedIdentifier\n    | BACKQUOTED_IDENTIFIER                                                             #backQuotedIdentifier\n    ;\n\nstring\n    : SINGLE_QUOTED_STRING                                                              #basicSingleQuotedStringLiteral\n    | DOUBLE_QUOTED_STRING                                                              #basicDoubleQuotedStringLiteral\n    | value=SINGLE_QUOTED_UNICODE_STRING (UESCAPE uesc=SINGLE_QUOTED_STRING)?           #unicodeSingleQuotedStringLiteral\n    | value=DOUBLE_QUOTED_UNICODE_STRING (UESCAPE uesc=DOUBLE_QUOTED_STRING)?           #unicodeDoubleQuotedStringLiteral\n    ;\n\nnumber\n    : value=DECIMAL_VALUE                                                               #decimalLiteral\n    | value=DOUBLE_VALUE                                                                #scientificLiteral\n    | value=INTEGER_VALUE                                                               #integerLiteral\n    ;\n\npositionalArgument\n    : expression\n    ;\n\nnamedArgument\n    : simpleIdentifier ASSIGN expression\n    ;\n\n//\n// COMMANDS\n//\n\nLET_COMMAND: 'LET' | 'let';\nWHERE_COMMAND: 'WHERE' | 'where';\nSELECT_COMMAND: 'SELECT' | 'select';\nDROP_COMMAND: 'DROP' | 'drop';\nFROM_COMMAND: 'FROM' | 'from';\nUNION_COMMAND: 'UNION' | 'union';\nLIMIT_COMMAND: 'LIMIT' | 'limit';\nPARSE_COMMAND: 'PARSE' | 'parse';\nWITHIN_COMMAND: 'WITHIN' | 'within';\nAGG_COMMAND: 'AGG' | 'agg';\nWINDOW_COMMAND: 'WINDOW' | 'window';\nAPPEND_COMMAND: 'APPEND' | 'append';\nJOIN_COMMAND: 'JOIN' | 'join';\nLOOKUP_COMMAND: 'LOOKUP' | 'lookup';\nEXPLODE_COMMAND: 'EXPLODE' | 'explode';\nUNNEST_COMMAND: 'UNNEST' | 'unnest';\nNEST_COMMAND: 'NEST' | 'nest';\nROWS_COMMAND: 'ROWS' | 'rows';\nMATCH_COMMAND: 'MATCH' | 'match';\n\nAS: 'AS' | 'as';\nNODROP: 'NODROP' | 'nodrop';\n\n//\n// Operators\n//\n\nPLUS: '+';\nMINUS: '-';\nASTERISK: '*';\nSLASH: '/';\nPERCENT: '%';\nLCURLY: '{';\nRCURLY: '}';\nCOLON: ':';\nQUESTIONMARK: '?';\n\nEQ: '==';\nNEQ: '!=';\nLT: '<';\nLTE: '<=';\nGT: '>';\nGTE: '>=';\nRANGE: '..';\n\nASSIGN: '=';\n\n//\n// Keywords\n//\n\nAND: 'AND' | 'and';\nFALSE: 'FALSE' | 'false';\nIS: 'IS' | 'is';\nNOT: 'NOT' | 'not';\nISNOT: 'IS NOT' | 'is not';\nIN: 'IN' | 'in';\nNOTIN: 'NOT IN' | 'not in';\nNULL: 'NULL' | 'null';\nOR: 'OR' | 'or';\nTRUE: 'TRUE' | 'true';\nUESCAPE: 'UESCAPE' | 'uescape';\nWITH: 'WITH' | 'with';\nBY: 'BY' | 'by';\nSORT: 'SORT' | 'sort';\nASC: 'ASC' | 'asc';\nDESC: 'DESC' | 'desc';\nDISTINCT_BY: 'DISTINCT BY' | 'distinct by';\nON: 'ON' | 'on';\nWHEN: 'WHEN' | 'when';\n\n//\n// Symbols\n//\n\nCOMMA: ',';\nPIPE: '|';\nLPARENS: '(';\nRPARENS: ')';\nDOT: '.';\nLBRACKET: '[';\nRBRACKET: ']';\n\n//\n// Literals\n//\n\nSINGLE_QUOTED_STRING\n        : '\\'' ( ~'\\'' | '\\'\\'')* '\\''\n        ;\nDOUBLE_QUOTED_STRING\n        : '\"' ( ~'\"' | '\"\"')* '\"'\n        ;\n\nSINGLE_QUOTED_UNICODE_STRING\n        : 'U&\\'' ( ~'\\'' | '\\'\\'')* '\\''    // Unicode string with default escape character: U&'Hello winter \\2603 !'\n        ;\n\nDOUBLE_QUOTED_UNICODE_STRING\n        : 'U&\"' ( ~'\"' | '\"\"')* '\"'         // Unicode string with custom escape character: U&'Hello winter #2603 !' UESCAPE '#'\n        ;\n\n// Note: we allow any character inside the binary literal and validate\n// its a correct literal when the AST is being constructed. This\n// allows us to provide more meaningful error messages to the user\nBINARY_LITERAL\n    : 'x\\'' (~'\\'')* '\\''\n    ;\n\nNANOSECOND_INTERVAL\n    : DECIMAL_INTEGER 'ns'\n    ;\n\nMICROSECOND_INTERVAL\n    : DECIMAL_INTEGER 'us'\n    ;\n\nMILLISECOND_INTERVAL\n    : DECIMAL_INTEGER 'ms'\n    ;\n\nSECOND_INTERVAL\n    : DECIMAL_INTEGER  ('s' | 'sec' | 'secs' | 'second' | 'seconds')\n    ;\n\nMINUTE_INTERVAL\n    : DECIMAL_INTEGER  ('m' | 'min' | 'mins' | 'minute' | 'minutes')\n    ;\n\nHOUR_INTERVAL\n    : DECIMAL_INTEGER ('h' | 'hr' | 'hrs' | 'hour' | 'hours')\n    ;\n\nDAY_INTERVAL\n    : DECIMAL_INTEGER ('d' | 'day' | 'days')\n    ;\n\nWEEK_INTERVAL\n    : DECIMAL_INTEGER ('w' | 'week' | 'weeks')\n    ;\n\nMONTH_INTERVAL\n    : DECIMAL_INTEGER ('mon' | 'month' | 'months')\n    ;\n\nQUARTER_INTERVAL\n    : DECIMAL_INTEGER ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')\n    ;\n\nYEAR_INTERVAL\n    : DECIMAL_INTEGER ('y' | 'yr' | 'yrs' | 'year' | 'years')\n    ;\n\nROWS_LITERAL\n    : DECIMAL_INTEGER ('r' | 'row' | 'rows')\n    ;\n\nSECOND_TRUNC\n    : '@'  ('s' | 'sec' | 'secs' | 'second' | 'seconds')\n    ;\n\nMINUTE_TRUNC\n    : '@'  ('m' | 'min' | 'mins' | 'minute' | 'minutes')\n    ;\n\nHOUR_TRUNC\n    : '@' ('h' | 'hr' | 'hrs' | 'hour' | 'hours')\n    ;\n\nDAY_TRUNC\n    : '@' ('d' | 'day' | 'days')\n    ;\n\nWEEK_TRUNC\n    : '@' ('w' | 'week' | 'weeks')\n    ;\n\nMONTH_TRUNC\n    : '@' ('mon' | 'month' | 'months')\n    ;\n\nQUARTER_TRUNC\n    : '@' ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')\n    ;\n\nYEAR_TRUNC\n    : '@' ('y' | 'yr' | 'yrs' | 'year' | 'years')\n    ;\n\nINTEGER_VALUE\n    : DECIMAL_INTEGER\n    | HEXADECIMAL_INTEGER\n    | OCTAL_INTEGER\n    | BINARY_INTEGER\n    ;\n\nDECIMAL_VALUE\n    : DECIMAL_INTEGER '.' DECIMAL_INTEGER\n    | '.' DECIMAL_INTEGER\n    ;\n\nDOUBLE_VALUE\n    : DIGIT+ ('.' DIGIT*)? EXPONENT\n    | '.' DIGIT+ EXPONENT\n    ;\n\nIDENTIFIER\n    : [a-zA-Z_][a-zA-Z_0-9]*\n    ;\n\nBACKQUOTED_IDENTIFIER\n    : '`' ( ~'`' | '``' )* '`'\n    ;\n\nfragment DECIMAL_INTEGER\n    : DIGIT ('_'? DIGIT)*\n    ;\n\nfragment HEXADECIMAL_INTEGER\n    : '0x' ('_'? (DIGIT | [A-F]))+\n    ;\n\nfragment OCTAL_INTEGER\n    : '0o' ('_'? [0-7])+\n    ;\n\nfragment BINARY_INTEGER\n    : '0b' ('_'? [01])+\n    ;\n\nfragment EXPONENT\n    : 'e' [+-]? DIGIT+\n    ;\n\nfragment DIGIT\n    : [0-9]\n    ;\n\n//\n// Comments and whitespace\n//\n\nSIMPLE_COMMENT\n    : '//' ~[\\r\\n]* '\\r'? '\\n'? -> channel(HIDDEN)\n    ;\n\nBRACKETED_COMMENT\n    : '/*' .*? '*/' -> channel(HIDDEN)\n    ;\n\nWS\n    : [ \\r\\n\\t]+ -> skip\n    ;\n";
-
-declare const getDatasetsFromQuery: (catalog: Catalog, hamelinInput: string) => Promise<QueryDatasetsResult>;
-
-declare const getFunctionDescriptions: () => Promise<FunctionDescription[]>;
-
-/**
- * Returns the top level limit information from the provided Hamelin query.
- */
-declare const getLimits: (hamelinQuery: string) => number[];
-
-type QuerySort = {
-    column: string;
-    direction: "asc" | "desc" | null;
-};
-/**
- * Returns the top level sorting information from the provided Hamelin query.
- */
-declare const getSorts: (hamelinQuery: string) => QuerySort[];
-
-declare const sampleCatalog: Catalog;
+declare function getSyntaxCompletions(input: string, pos: number): Completion | null;
 
-export { AggCommandContext, AnyNumberContext, AppendCommandContext, ArrayLiteralContext, AssignmentClauseContext, AssignmentContext, AtLeastOneContext, BackQuotedIdentifierContext, BasicDoubleQuotedStringLiteralContext, BasicSingleQuotedStringLiteralContext, BinaryLiteralContext, BinaryOperatorContext, BooleanLiteralContext, CastContext, type Catalog, CatalogProvider, type Column, ColumnReferenceAltContext, ColumnReferenceContext, CommandContext, CommandEOFContext, type CompileQueryResult, Compiler, type Completion, type CompletionItem, type CompletionItemKind, type Context, type ContextualCompletion, type ContextualResult, type ContextualTranslationError, type ContextualTranslationErrors, type DMLTranslation, DecimalLiteralContext, DerefContext, DropCommandContext, ExactlyContext, ExplodeCommandContext, ExpressionContext, ExpressionEOFContext, ExpressionQueryContext, FromClauseContext, FromCommandContext, FunctionCallContext, type FunctionDescription, GroupClauseContext, HamelinLexer, HamelinListener, HamelinParser, type HamelinType, HamelinVisitor, HamelintypeContext, IdentifierContext, IdentifierEOFContext, IndexAccessContext, type InitInput, type InitOutput, IntegerLiteralContext, IntervalLiteralContext, JoinCommandContext, type LanguageArea, LetCommandContext, type Level, LimitCommandContext, MatchCommandContext, MatchDefineContext, NamedArgumentContext, NestCommandContext, NestedContext, NullLiteralContext, NumberContext, NumericLiteralContext, PairLiteralContext, ParameterizedTypeContext, ParenthesizedExpressionContext, ParseCommandContext, PatternContext, PipelineAltContext, PipelineContext, PipelineEOFContext, PositionalArgumentContext, QuantifiedContext, QuantifierContext, QueryContext, type QueryDatasetsResult, QueryEOFContext, type QuerySort, type QueryTranslation, RowsLiteralContext, ScientificLiteralContext, SelectCommandContext, SelectionContext, SimpleIdentifierContext, SimpleIdentifierEOFContext, SimpleTypeContext, SortCommandContext, SortExpressionContext, type Stage, StandaloneQueryContext, type StatementTranslation, StringContext, StringLiteralContext, StructLiteralContext, StructTypeContext, type SyncInitInput, TableAliasContext, TableReferenceContext, type Translation, type TranslationError, type TranslationErrors, TsTruncContext, TsTruncTimestampLiteralContext, TupleLiteralContext, TupleTypeContext, TypeWithArgumentsContext, UnaryPostfixOperatorContext, UnaryPrefixOperatorContext, UnboundRangeLiteralContext, UnicodeDoubleQuotedStringLiteralContext, UnicodeSingleQuotedStringLiteralContext, UnionCommandContext, UnnestCommandContext, UnquotedIdentifierContext, WhereCommandContext, WindowCommandContext, WithQueryContext, WithinCommandContext, ZeroOrOneContext, compileHamelin, createCompiler, getDatasetsFromQuery, getFunctionDescriptions, getLimits, getSorts, hamelinGrammar, initSync, sampleCatalog };
+export { type Catalog, type Column, type Completion, type CompletionItem, type ContextualResult, type ContextualTranslationError, type ContextualTranslationErrors, type FunctionDescription, type HamelinType, type QuerySort, type QueryTranslation, type Translation, type TranslationError, compileHamelin, createCompiler, getAggregations, getDatasetsFromQuery, getFunctionDescriptions, getLimits, getSelectedFields, getSorts, getSyntaxCompletions, hamelinGrammar, hamelinPrompt, parseTokenValueClass, sampleCatalog };