@hamelin.sh/compiler 0.2.9 → 0.2.10

package/dist/main.d.ts

@@ -1,49 +1,14 @@
-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[];
-}
-
-type TranslationErrors = TranslationError[];
-
-interface Context {
-    interval: { start: number; end: number };
-    message: string;
-}
+type CompileQueryResult = { Ok: QueryTranslation } | { Err: ContextualTranslationErrors };
 
-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 Level = "Error" | "Warning" | "Info";
-
 interface ContextualResult {
     hamelin: string;
     errors: ContextualTranslationError[];
@@ -51,13 +16,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,26 +44,59 @@ interface CompletionItem {
     section: string | undefined;
 }
 
+interface Translation {
+    sql: string;
+    columns: Column[];
+}
+
+interface QueryTranslation {
+    translation: Translation;
+}
+
 interface Completion {
     at: { start: number; end: number };
     filter: boolean | undefined;
     items: CompletionItem[];
 }
 
-interface Translation {
-    sql: string;
-    columns: Column[];
+type CompletionItemKind = "Text" | "Variable" | "Function" | "Command" | "Keyword";
+
+interface Context {
+    interval: { start: number; end: number };
+    message: string;
 }
 
-interface DMLTranslation {
-    translation: Translation;
+type Stage = "Translation" | "Parsing" | "SemanticAnalysis";
+
+type Level = "Error" | "Warning" | "Info";
+
+interface ContextualTranslationErrors {
+    hamelin: string;
+    errors: ContextualTranslationError[];
 }
 
-interface QueryTranslation {
-    translation: Translation;
+interface ContextualTranslationError {
+    error: TranslationError;
+    pretty: string;
+}
+
+type LanguageArea = "FunctionCall" | "Operator" | "Deref" | "IndexAccess" | "Parsing";
+
+interface TranslationError {
+    area: LanguageArea | undefined;
+    stage: Stage;
+    level: Level;
+    primary: Context;
+    supporting: Context[] | undefined;
+    source_desc: string | undefined;
+}
+
+interface FunctionDescription {
+    name: string;
+    parameters: string;
 }
 
-type StatementTranslation = { Query: QueryTranslation } | { DML: DMLTranslation };
+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[] };
 
@@ -114,8 +105,6 @@ interface Column {
     type: HamelinType;
 }
 
-type Catalog = Record<string, Column[]>;
-
 declare class CatalogProvider {
   private constructor();
   free(): void;
@@ -125,2860 +114,66 @@ 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>;
 
-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 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";
 
-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, parseTokenValueClass, sampleCatalog };