@malloydata/malloy 0.0.1

package/dist/lang/lib/Malloy/MalloyParser.d.ts

@@ -0,0 +1,1920 @@
+import { ATN } from "antlr4ts/atn/ATN";
+import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
+import { Parser } from "antlr4ts/Parser";
+import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
+import { RuleContext } from "antlr4ts/RuleContext";
+import { TerminalNode } from "antlr4ts/tree/TerminalNode";
+import { TokenStream } from "antlr4ts/TokenStream";
+import { Vocabulary } from "antlr4ts/Vocabulary";
+import { MalloyListener } from "./MalloyListener";
+import { MalloyVisitor } from "./MalloyVisitor";
+export declare class MalloyParser extends Parser {
+    static readonly JSON_STRING = 1;
+    static readonly ACCEPT = 2;
+    static readonly AGGREGATE = 3;
+    static readonly DECLARE = 4;
+    static readonly DIMENSION = 5;
+    static readonly EXCEPT = 6;
+    static readonly EXPLORE = 7;
+    static readonly GROUP_BY = 8;
+    static readonly HAVING = 9;
+    static readonly INDEX = 10;
+    static readonly JOIN_CROSS = 11;
+    static readonly JOIN_ONE = 12;
+    static readonly JOIN_MANY = 13;
+    static readonly LIMIT = 14;
+    static readonly MEASURE = 15;
+    static readonly NEST = 16;
+    static readonly ORDER_BY = 17;
+    static readonly PRIMARY_KEY = 18;
+    static readonly PROJECT = 19;
+    static readonly QUERY = 20;
+    static readonly RENAME = 21;
+    static readonly SAMPLE = 22;
+    static readonly SOURCE = 23;
+    static readonly SQL = 24;
+    static readonly TOP = 25;
+    static readonly WHERE = 26;
+    static readonly ALL = 27;
+    static readonly AND = 28;
+    static readonly AS = 29;
+    static readonly ASC = 30;
+    static readonly AVG = 31;
+    static readonly BOOLEAN = 32;
+    static readonly BY = 33;
+    static readonly CASE = 34;
+    static readonly CAST = 35;
+    static readonly CONDITION = 36;
+    static readonly COUNT = 37;
+    static readonly DATE = 38;
+    static readonly DAY = 39;
+    static readonly DESC = 40;
+    static readonly DISTINCT = 41;
+    static readonly ELSE = 42;
+    static readonly END = 43;
+    static readonly EXCLUDE = 44;
+    static readonly FALSE = 45;
+    static readonly FOR = 46;
+    static readonly FROM = 47;
+    static readonly FROM_SQL = 48;
+    static readonly HAS = 49;
+    static readonly HOUR = 50;
+    static readonly IMPORT = 51;
+    static readonly IS = 52;
+    static readonly JSON = 53;
+    static readonly LAST = 54;
+    static readonly MAX = 55;
+    static readonly MIN = 56;
+    static readonly MINUTE = 57;
+    static readonly MONTH = 58;
+    static readonly NOT = 59;
+    static readonly NOW = 60;
+    static readonly NULL = 61;
+    static readonly NUMBER = 62;
+    static readonly ON = 63;
+    static readonly OR = 64;
+    static readonly PICK = 65;
+    static readonly QMARK = 66;
+    static readonly QUARTER = 67;
+    static readonly SECOND = 68;
+    static readonly STRING = 69;
+    static readonly SUM = 70;
+    static readonly TABLE = 71;
+    static readonly THEN = 72;
+    static readonly THIS = 73;
+    static readonly TIMESTAMP = 74;
+    static readonly TO = 75;
+    static readonly TRUE = 76;
+    static readonly TURTLE = 77;
+    static readonly WEEK = 78;
+    static readonly WHEN = 79;
+    static readonly WITH = 80;
+    static readonly YEAR = 81;
+    static readonly UNGROUPED = 82;
+    static readonly STRING_ESCAPE = 83;
+    static readonly HACKY_REGEX = 84;
+    static readonly STRING_LITERAL = 85;
+    static readonly AMPER = 86;
+    static readonly ARROW = 87;
+    static readonly FAT_ARROW = 88;
+    static readonly OPAREN = 89;
+    static readonly CPAREN = 90;
+    static readonly OBRACK = 91;
+    static readonly CBRACK = 92;
+    static readonly OCURLY = 93;
+    static readonly CCURLY = 94;
+    static readonly DOUBLECOLON = 95;
+    static readonly COLON = 96;
+    static readonly COMMA = 97;
+    static readonly DOT = 98;
+    static readonly LT = 99;
+    static readonly GT = 100;
+    static readonly EQ = 101;
+    static readonly NE = 102;
+    static readonly LTE = 103;
+    static readonly GTE = 104;
+    static readonly PLUS = 105;
+    static readonly MINUS = 106;
+    static readonly STAR = 107;
+    static readonly STARSTAR = 108;
+    static readonly SLASH = 109;
+    static readonly BAR = 110;
+    static readonly SEMI = 111;
+    static readonly NOT_MATCH = 112;
+    static readonly MATCH = 113;
+    static readonly LITERAL_TIMESTAMP = 114;
+    static readonly LITERAL_DAY = 115;
+    static readonly LITERAL_QUARTER = 116;
+    static readonly LITERAL_MONTH = 117;
+    static readonly LITERAL_WEEK = 118;
+    static readonly LITERAL_YEAR = 119;
+    static readonly IDENTIFIER = 120;
+    static readonly PERCENT_LITERAL = 121;
+    static readonly INTEGER_LITERAL = 122;
+    static readonly NUMERIC_LITERAL = 123;
+    static readonly OBJECT_NAME_LITERAL = 124;
+    static readonly BLOCK_COMMENT = 125;
+    static readonly COMMENT_TO_EOL = 126;
+    static readonly WHITE_SPACE = 127;
+    static readonly SQL_STRING = 128;
+    static readonly UNWATED_CHARS_TRAILING_NUMBERS = 129;
+    static readonly UNEXPECTED_CHAR = 130;
+    static readonly RULE_malloyDocument = 0;
+    static readonly RULE_malloyStatement = 1;
+    static readonly RULE_defineExploreStatement = 2;
+    static readonly RULE_exploreKeyword = 3;
+    static readonly RULE_defineQuery = 4;
+    static readonly RULE_topLevelAnonQueryDef = 5;
+    static readonly RULE_defineSQLStatement = 6;
+    static readonly RULE_sqlStatementDef = 7;
+    static readonly RULE_importStatement = 8;
+    static readonly RULE_importURL = 9;
+    static readonly RULE_topLevelQueryDefs = 10;
+    static readonly RULE_topLevelQueryDef = 11;
+    static readonly RULE_refineOperator = 12;
+    static readonly RULE_query = 13;
+    static readonly RULE_pipelineFromName = 14;
+    static readonly RULE_firstSegment = 15;
+    static readonly RULE_pipeElement = 16;
+    static readonly RULE_exploreTable = 17;
+    static readonly RULE_queryProperties = 18;
+    static readonly RULE_filterShortcut = 19;
+    static readonly RULE_exploreQueryName = 20;
+    static readonly RULE_queryName = 21;
+    static readonly RULE_exploreDefinitionList = 22;
+    static readonly RULE_exploreDefinition = 23;
+    static readonly RULE_explore = 24;
+    static readonly RULE_exploreSource = 25;
+    static readonly RULE_exploreNameDef = 26;
+    static readonly RULE_exploreName = 27;
+    static readonly RULE_exploreProperties = 28;
+    static readonly RULE_exploreStatement = 29;
+    static readonly RULE_renameList = 30;
+    static readonly RULE_exploreRenameDef = 31;
+    static readonly RULE_dimensionDefList = 32;
+    static readonly RULE_measureDefList = 33;
+    static readonly RULE_fieldDef = 34;
+    static readonly RULE_fieldNameDef = 35;
+    static readonly RULE_joinNameDef = 36;
+    static readonly RULE_measureDef = 37;
+    static readonly RULE_declareStatement = 38;
+    static readonly RULE_joinStatement = 39;
+    static readonly RULE_joinList = 40;
+    static readonly RULE_joinDef = 41;
+    static readonly RULE_joinExpression = 42;
+    static readonly RULE_filterStatement = 43;
+    static readonly RULE_filteredBy = 44;
+    static readonly RULE_filterClauseList = 45;
+    static readonly RULE_whereStatement = 46;
+    static readonly RULE_havingStatement = 47;
+    static readonly RULE_subQueryDefList = 48;
+    static readonly RULE_exploreQueryNameDef = 49;
+    static readonly RULE_exploreQueryDef = 50;
+    static readonly RULE_queryStatement = 51;
+    static readonly RULE_groupByStatement = 52;
+    static readonly RULE_queryFieldList = 53;
+    static readonly RULE_dimensionDef = 54;
+    static readonly RULE_queryFieldEntry = 55;
+    static readonly RULE_nestStatement = 56;
+    static readonly RULE_nestedQueryList = 57;
+    static readonly RULE_nestEntry = 58;
+    static readonly RULE_aggregateStatement = 59;
+    static readonly RULE_projectStatement = 60;
+    static readonly RULE_orderByStatement = 61;
+    static readonly RULE_ordering = 62;
+    static readonly RULE_orderBySpec = 63;
+    static readonly RULE_limitStatement = 64;
+    static readonly RULE_bySpec = 65;
+    static readonly RULE_topStatement = 66;
+    static readonly RULE_indexElement = 67;
+    static readonly RULE_indexFields = 68;
+    static readonly RULE_indexStatement = 69;
+    static readonly RULE_sampleStatement = 70;
+    static readonly RULE_sampleSpec = 71;
+    static readonly RULE_aggregate = 72;
+    static readonly RULE_malloyType = 73;
+    static readonly RULE_compareOp = 74;
+    static readonly RULE_literal = 75;
+    static readonly RULE_dateLiteral = 76;
+    static readonly RULE_tableName = 77;
+    static readonly RULE_id = 78;
+    static readonly RULE_timeframe = 79;
+    static readonly RULE_ungroup = 80;
+    static readonly RULE_fieldExpr = 81;
+    static readonly RULE_partialAllowedFieldExpr = 82;
+    static readonly RULE_pickStatement = 83;
+    static readonly RULE_pick = 84;
+    static readonly RULE_argumentList = 85;
+    static readonly RULE_fieldNameList = 86;
+    static readonly RULE_fieldCollection = 87;
+    static readonly RULE_collectionMember = 88;
+    static readonly RULE_fieldPath = 89;
+    static readonly RULE_joinName = 90;
+    static readonly RULE_fieldName = 91;
+    static readonly RULE_justExpr = 92;
+    static readonly RULE_json = 93;
+    static readonly RULE_jsonValue = 94;
+    static readonly RULE_jsonObject = 95;
+    static readonly RULE_jsonProperty = 96;
+    static readonly RULE_jsonArray = 97;
+    static readonly RULE_sqlBlock = 98;
+    static readonly RULE_sqlExploreNameRef = 99;
+    static readonly RULE_sqlCommandNameDef = 100;
+    static readonly RULE_connectionName = 101;
+    static readonly ruleNames: string[];
+    private static readonly _LITERAL_NAMES;
+    private static readonly _SYMBOLIC_NAMES;
+    static readonly VOCABULARY: Vocabulary;
+    get vocabulary(): Vocabulary;
+    get grammarFileName(): string;
+    get ruleNames(): string[];
+    get serializedATN(): string;
+    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
+    constructor(input: TokenStream);
+    malloyDocument(): MalloyDocumentContext;
+    malloyStatement(): MalloyStatementContext;
+    defineExploreStatement(): DefineExploreStatementContext;
+    exploreKeyword(): ExploreKeywordContext;
+    defineQuery(): DefineQueryContext;
+    topLevelAnonQueryDef(): TopLevelAnonQueryDefContext;
+    defineSQLStatement(): DefineSQLStatementContext;
+    sqlStatementDef(): SqlStatementDefContext;
+    importStatement(): ImportStatementContext;
+    importURL(): ImportURLContext;
+    topLevelQueryDefs(): TopLevelQueryDefsContext;
+    topLevelQueryDef(): TopLevelQueryDefContext;
+    refineOperator(): RefineOperatorContext;
+    query(): QueryContext;
+    pipelineFromName(): PipelineFromNameContext;
+    firstSegment(): FirstSegmentContext;
+    pipeElement(): PipeElementContext;
+    exploreTable(): ExploreTableContext;
+    queryProperties(): QueryPropertiesContext;
+    filterShortcut(): FilterShortcutContext;
+    exploreQueryName(): ExploreQueryNameContext;
+    queryName(): QueryNameContext;
+    exploreDefinitionList(): ExploreDefinitionListContext;
+    exploreDefinition(): ExploreDefinitionContext;
+    explore(): ExploreContext;
+    exploreSource(): ExploreSourceContext;
+    exploreNameDef(): ExploreNameDefContext;
+    exploreName(): ExploreNameContext;
+    exploreProperties(): ExplorePropertiesContext;
+    exploreStatement(): ExploreStatementContext;
+    renameList(): RenameListContext;
+    exploreRenameDef(): ExploreRenameDefContext;
+    dimensionDefList(): DimensionDefListContext;
+    measureDefList(): MeasureDefListContext;
+    fieldDef(): FieldDefContext;
+    fieldNameDef(): FieldNameDefContext;
+    joinNameDef(): JoinNameDefContext;
+    measureDef(): MeasureDefContext;
+    declareStatement(): DeclareStatementContext;
+    joinStatement(): JoinStatementContext;
+    joinList(): JoinListContext;
+    joinDef(): JoinDefContext;
+    joinExpression(): JoinExpressionContext;
+    filterStatement(): FilterStatementContext;
+    filteredBy(): FilteredByContext;
+    filterClauseList(): FilterClauseListContext;
+    whereStatement(): WhereStatementContext;
+    havingStatement(): HavingStatementContext;
+    subQueryDefList(): SubQueryDefListContext;
+    exploreQueryNameDef(): ExploreQueryNameDefContext;
+    exploreQueryDef(): ExploreQueryDefContext;
+    queryStatement(): QueryStatementContext;
+    groupByStatement(): GroupByStatementContext;
+    queryFieldList(): QueryFieldListContext;
+    dimensionDef(): DimensionDefContext;
+    queryFieldEntry(): QueryFieldEntryContext;
+    nestStatement(): NestStatementContext;
+    nestedQueryList(): NestedQueryListContext;
+    nestEntry(): NestEntryContext;
+    aggregateStatement(): AggregateStatementContext;
+    projectStatement(): ProjectStatementContext;
+    orderByStatement(): OrderByStatementContext;
+    ordering(): OrderingContext;
+    orderBySpec(): OrderBySpecContext;
+    limitStatement(): LimitStatementContext;
+    bySpec(): BySpecContext;
+    topStatement(): TopStatementContext;
+    indexElement(): IndexElementContext;
+    indexFields(): IndexFieldsContext;
+    indexStatement(): IndexStatementContext;
+    sampleStatement(): SampleStatementContext;
+    sampleSpec(): SampleSpecContext;
+    aggregate(): AggregateContext;
+    malloyType(): MalloyTypeContext;
+    compareOp(): CompareOpContext;
+    literal(): LiteralContext;
+    dateLiteral(): DateLiteralContext;
+    tableName(): TableNameContext;
+    id(): IdContext;
+    timeframe(): TimeframeContext;
+    ungroup(): UngroupContext;
+    fieldExpr(): FieldExprContext;
+    fieldExpr(_p: number): FieldExprContext;
+    partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
+    pickStatement(): PickStatementContext;
+    pick(): PickContext;
+    argumentList(): ArgumentListContext;
+    fieldNameList(): FieldNameListContext;
+    fieldCollection(): FieldCollectionContext;
+    collectionMember(): CollectionMemberContext;
+    fieldPath(): FieldPathContext;
+    joinName(): JoinNameContext;
+    fieldName(): FieldNameContext;
+    justExpr(): JustExprContext;
+    json(): JsonContext;
+    jsonValue(): JsonValueContext;
+    jsonObject(): JsonObjectContext;
+    jsonProperty(): JsonPropertyContext;
+    jsonArray(): JsonArrayContext;
+    sqlBlock(): SqlBlockContext;
+    sqlExploreNameRef(): SqlExploreNameRefContext;
+    sqlCommandNameDef(): SqlCommandNameDefContext;
+    connectionName(): ConnectionNameContext;
+    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
+    private fieldExpr_sempred;
+    private static readonly _serializedATNSegments;
+    private static readonly _serializedATNSegment0;
+    private static readonly _serializedATNSegment1;
+    static readonly _serializedATN: string;
+    static __ATN: ATN;
+    static get _ATN(): ATN;
+}
+export declare class MalloyDocumentContext extends ParserRuleContext {
+    EOF(): TerminalNode;
+    malloyStatement(): MalloyStatementContext[];
+    malloyStatement(i: number): MalloyStatementContext;
+    SEMI(): TerminalNode[];
+    SEMI(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class MalloyStatementContext extends ParserRuleContext {
+    defineExploreStatement(): DefineExploreStatementContext | undefined;
+    defineSQLStatement(): DefineSQLStatementContext | undefined;
+    defineQuery(): DefineQueryContext | undefined;
+    importStatement(): ImportStatementContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefineExploreStatementContext extends ParserRuleContext {
+    exploreKeyword(): ExploreKeywordContext;
+    exploreDefinitionList(): ExploreDefinitionListContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreKeywordContext extends ParserRuleContext {
+    EXPLORE(): TerminalNode | undefined;
+    SOURCE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefineQueryContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: DefineQueryContext): void;
+}
+export declare class NamedQueries_stubContext extends DefineQueryContext {
+    QUERY(): TerminalNode;
+    topLevelQueryDefs(): TopLevelQueryDefsContext;
+    constructor(ctx: DefineQueryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class AnonymousQueryContext extends DefineQueryContext {
+    QUERY(): TerminalNode;
+    topLevelAnonQueryDef(): TopLevelAnonQueryDefContext;
+    constructor(ctx: DefineQueryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class TopLevelAnonQueryDefContext extends ParserRuleContext {
+    query(): QueryContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefineSQLStatementContext extends ParserRuleContext {
+    SQL(): TerminalNode;
+    sqlStatementDef(): SqlStatementDefContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SqlStatementDefContext extends ParserRuleContext {
+    sqlBlock(): SqlBlockContext;
+    sqlCommandNameDef(): SqlCommandNameDefContext | undefined;
+    IS(): TerminalNode | undefined;
+    ON(): TerminalNode | undefined;
+    connectionName(): ConnectionNameContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ImportStatementContext extends ParserRuleContext {
+    IMPORT(): TerminalNode;
+    importURL(): ImportURLContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ImportURLContext extends ParserRuleContext {
+    JSON_STRING(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class TopLevelQueryDefsContext extends ParserRuleContext {
+    topLevelQueryDef(): TopLevelQueryDefContext[];
+    topLevelQueryDef(i: number): TopLevelQueryDefContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class TopLevelQueryDefContext extends ParserRuleContext {
+    queryName(): QueryNameContext;
+    IS(): TerminalNode;
+    query(): QueryContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class RefineOperatorContext extends ParserRuleContext {
+    PLUS(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QueryContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: QueryContext): void;
+}
+export declare class ExploreArrowQueryContext extends QueryContext {
+    explore(): ExploreContext;
+    ARROW(): TerminalNode;
+    pipelineFromName(): PipelineFromNameContext;
+    constructor(ctx: QueryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ArrowQueryContext extends QueryContext {
+    ARROW(): TerminalNode;
+    queryName(): QueryNameContext;
+    queryProperties(): QueryPropertiesContext | undefined;
+    pipeElement(): PipeElementContext[];
+    pipeElement(i: number): PipeElementContext;
+    refineOperator(): RefineOperatorContext | undefined;
+    constructor(ctx: QueryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class PipelineFromNameContext extends ParserRuleContext {
+    firstSegment(): FirstSegmentContext;
+    pipeElement(): PipeElementContext[];
+    pipeElement(i: number): PipeElementContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FirstSegmentContext extends ParserRuleContext {
+    queryProperties(): QueryPropertiesContext | undefined;
+    exploreQueryName(): ExploreQueryNameContext | undefined;
+    refineOperator(): RefineOperatorContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class PipeElementContext extends ParserRuleContext {
+    ARROW(): TerminalNode;
+    queryProperties(): QueryPropertiesContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreTableContext extends ParserRuleContext {
+    TABLE(): TerminalNode;
+    OPAREN(): TerminalNode;
+    tableName(): TableNameContext;
+    CPAREN(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QueryPropertiesContext extends ParserRuleContext {
+    filterShortcut(): FilterShortcutContext | undefined;
+    OCURLY(): TerminalNode | undefined;
+    CCURLY(): TerminalNode | undefined;
+    queryStatement(): QueryStatementContext[];
+    queryStatement(i: number): QueryStatementContext;
+    SEMI(): TerminalNode[];
+    SEMI(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FilterShortcutContext extends ParserRuleContext {
+    OCURLY(): TerminalNode;
+    QMARK(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    CCURLY(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreQueryNameContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QueryNameContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreDefinitionListContext extends ParserRuleContext {
+    exploreDefinition(): ExploreDefinitionContext[];
+    exploreDefinition(i: number): ExploreDefinitionContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreDefinitionContext extends ParserRuleContext {
+    exploreNameDef(): ExploreNameDefContext;
+    IS(): TerminalNode;
+    explore(): ExploreContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreContext extends ParserRuleContext {
+    exploreSource(): ExploreSourceContext;
+    exploreProperties(): ExplorePropertiesContext | undefined;
+    refineOperator(): RefineOperatorContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreSourceContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ExploreSourceContext): void;
+}
+export declare class NamedSourceContext extends ExploreSourceContext {
+    exploreName(): ExploreNameContext;
+    constructor(ctx: ExploreSourceContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class TableSourceContext extends ExploreSourceContext {
+    exploreTable(): ExploreTableContext;
+    constructor(ctx: ExploreSourceContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QuerySourceContext extends ExploreSourceContext {
+    FROM(): TerminalNode;
+    OPAREN(): TerminalNode;
+    query(): QueryContext;
+    CPAREN(): TerminalNode;
+    constructor(ctx: ExploreSourceContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SQLSourceContext extends ExploreSourceContext {
+    FROM_SQL(): TerminalNode;
+    OPAREN(): TerminalNode;
+    sqlExploreNameRef(): SqlExploreNameRefContext;
+    CPAREN(): TerminalNode;
+    constructor(ctx: ExploreSourceContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreNameDefContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreNameContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExplorePropertiesContext extends ParserRuleContext {
+    OCURLY(): TerminalNode | undefined;
+    CCURLY(): TerminalNode | undefined;
+    exploreStatement(): ExploreStatementContext[];
+    exploreStatement(i: number): ExploreStatementContext;
+    SEMI(): TerminalNode[];
+    SEMI(i: number): TerminalNode;
+    filterShortcut(): FilterShortcutContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreStatementContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ExploreStatementContext): void;
+}
+export declare class DefExploreDimensionContext extends ExploreStatementContext {
+    DIMENSION(): TerminalNode;
+    dimensionDefList(): DimensionDefListContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefExploreMeasureContext extends ExploreStatementContext {
+    MEASURE(): TerminalNode;
+    measureDefList(): MeasureDefListContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefDeclare_stubContext extends ExploreStatementContext {
+    declareStatement(): DeclareStatementContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefJoin_stubContext extends ExploreStatementContext {
+    joinStatement(): JoinStatementContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefExploreWhereContext extends ExploreStatementContext {
+    whereStatement(): WhereStatementContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefExplorePrimaryKeyContext extends ExploreStatementContext {
+    PRIMARY_KEY(): TerminalNode;
+    fieldName(): FieldNameContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefExploreRenameContext extends ExploreStatementContext {
+    RENAME(): TerminalNode;
+    renameList(): RenameListContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefExploreEditFieldContext extends ExploreStatementContext {
+    fieldNameList(): FieldNameListContext;
+    ACCEPT(): TerminalNode | undefined;
+    EXCEPT(): TerminalNode | undefined;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefExploreQueryContext extends ExploreStatementContext {
+    QUERY(): TerminalNode;
+    subQueryDefList(): SubQueryDefListContext;
+    constructor(ctx: ExploreStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class RenameListContext extends ParserRuleContext {
+    exploreRenameDef(): ExploreRenameDefContext[];
+    exploreRenameDef(i: number): ExploreRenameDefContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreRenameDefContext extends ParserRuleContext {
+    fieldName(): FieldNameContext[];
+    fieldName(i: number): FieldNameContext;
+    IS(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DimensionDefListContext extends ParserRuleContext {
+    dimensionDef(): DimensionDefContext[];
+    dimensionDef(i: number): DimensionDefContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class MeasureDefListContext extends ParserRuleContext {
+    measureDef(): MeasureDefContext[];
+    measureDef(i: number): MeasureDefContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FieldDefContext extends ParserRuleContext {
+    fieldNameDef(): FieldNameDefContext;
+    IS(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FieldNameDefContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JoinNameDefContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class MeasureDefContext extends ParserRuleContext {
+    fieldDef(): FieldDefContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DeclareStatementContext extends ParserRuleContext {
+    DECLARE(): TerminalNode;
+    fieldDef(): FieldDefContext[];
+    fieldDef(i: number): FieldDefContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JoinStatementContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: JoinStatementContext): void;
+}
+export declare class DefJoinOneContext extends JoinStatementContext {
+    JOIN_ONE(): TerminalNode;
+    joinList(): JoinListContext;
+    constructor(ctx: JoinStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefJoinManyContext extends JoinStatementContext {
+    JOIN_MANY(): TerminalNode;
+    joinList(): JoinListContext;
+    constructor(ctx: JoinStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DefJoinCrossContext extends JoinStatementContext {
+    JOIN_CROSS(): TerminalNode;
+    joinList(): JoinListContext;
+    constructor(ctx: JoinStatementContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JoinListContext extends ParserRuleContext {
+    joinDef(): JoinDefContext[];
+    joinDef(i: number): JoinDefContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JoinDefContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: JoinDefContext): void;
+}
+export declare class JoinWithContext extends JoinDefContext {
+    joinNameDef(): JoinNameDefContext;
+    WITH(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    IS(): TerminalNode | undefined;
+    explore(): ExploreContext | undefined;
+    constructor(ctx: JoinDefContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JoinOnContext extends JoinDefContext {
+    joinNameDef(): JoinNameDefContext;
+    IS(): TerminalNode | undefined;
+    explore(): ExploreContext | undefined;
+    ON(): TerminalNode | undefined;
+    joinExpression(): JoinExpressionContext | undefined;
+    constructor(ctx: JoinDefContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JoinExpressionContext extends ParserRuleContext {
+    fieldExpr(): FieldExprContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FilterStatementContext extends ParserRuleContext {
+    whereStatement(): WhereStatementContext | undefined;
+    havingStatement(): HavingStatementContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FilteredByContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: FilteredByContext): void;
+}
+export declare class FilterByShortcutContext extends FilteredByContext {
+    QMARK(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    constructor(ctx: FilteredByContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FilterByWhereContext extends FilteredByContext {
+    whereStatement(): WhereStatementContext;
+    constructor(ctx: FilteredByContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FilterClauseListContext extends ParserRuleContext {
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class WhereStatementContext extends ParserRuleContext {
+    WHERE(): TerminalNode;
+    filterClauseList(): FilterClauseListContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class HavingStatementContext extends ParserRuleContext {
+    HAVING(): TerminalNode;
+    filterClauseList(): FilterClauseListContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SubQueryDefListContext extends ParserRuleContext {
+    exploreQueryDef(): ExploreQueryDefContext[];
+    exploreQueryDef(i: number): ExploreQueryDefContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreQueryNameDefContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExploreQueryDefContext extends ParserRuleContext {
+    exploreQueryNameDef(): ExploreQueryNameDefContext;
+    IS(): TerminalNode;
+    pipelineFromName(): PipelineFromNameContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QueryStatementContext extends ParserRuleContext {
+    groupByStatement(): GroupByStatementContext | undefined;
+    declareStatement(): DeclareStatementContext | undefined;
+    joinStatement(): JoinStatementContext | undefined;
+    projectStatement(): ProjectStatementContext | undefined;
+    indexStatement(): IndexStatementContext | undefined;
+    aggregateStatement(): AggregateStatementContext | undefined;
+    topStatement(): TopStatementContext | undefined;
+    limitStatement(): LimitStatementContext | undefined;
+    orderByStatement(): OrderByStatementContext | undefined;
+    whereStatement(): WhereStatementContext | undefined;
+    havingStatement(): HavingStatementContext | undefined;
+    nestStatement(): NestStatementContext | undefined;
+    sampleStatement(): SampleStatementContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class GroupByStatementContext extends ParserRuleContext {
+    GROUP_BY(): TerminalNode;
+    queryFieldList(): QueryFieldListContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QueryFieldListContext extends ParserRuleContext {
+    queryFieldEntry(): QueryFieldEntryContext[];
+    queryFieldEntry(i: number): QueryFieldEntryContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DimensionDefContext extends ParserRuleContext {
+    fieldDef(): FieldDefContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QueryFieldEntryContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: QueryFieldEntryContext): void;
+}
+export declare class QueryFieldRefContext extends QueryFieldEntryContext {
+    fieldPath(): FieldPathContext;
+    constructor(ctx: QueryFieldEntryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class QueryFieldDefContext extends QueryFieldEntryContext {
+    dimensionDef(): DimensionDefContext;
+    constructor(ctx: QueryFieldEntryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class NestStatementContext extends ParserRuleContext {
+    NEST(): TerminalNode;
+    nestedQueryList(): NestedQueryListContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class NestedQueryListContext extends ParserRuleContext {
+    nestEntry(): NestEntryContext[];
+    nestEntry(i: number): NestEntryContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class NestEntryContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: NestEntryContext): void;
+}
+export declare class NestExistingContext extends NestEntryContext {
+    queryName(): QueryNameContext;
+    queryProperties(): QueryPropertiesContext | undefined;
+    refineOperator(): RefineOperatorContext | undefined;
+    constructor(ctx: NestEntryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class NestDefContext extends NestEntryContext {
+    queryName(): QueryNameContext;
+    IS(): TerminalNode;
+    pipelineFromName(): PipelineFromNameContext;
+    constructor(ctx: NestEntryContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class AggregateStatementContext extends ParserRuleContext {
+    AGGREGATE(): TerminalNode;
+    queryFieldList(): QueryFieldListContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ProjectStatementContext extends ParserRuleContext {
+    PROJECT(): TerminalNode;
+    fieldCollection(): FieldCollectionContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class OrderByStatementContext extends ParserRuleContext {
+    ORDER_BY(): TerminalNode;
+    ordering(): OrderingContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class OrderingContext extends ParserRuleContext {
+    orderBySpec(): OrderBySpecContext[];
+    orderBySpec(i: number): OrderBySpecContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class OrderBySpecContext extends ParserRuleContext {
+    INTEGER_LITERAL(): TerminalNode | undefined;
+    fieldName(): FieldNameContext | undefined;
+    ASC(): TerminalNode | undefined;
+    DESC(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class LimitStatementContext extends ParserRuleContext {
+    LIMIT(): TerminalNode;
+    INTEGER_LITERAL(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class BySpecContext extends ParserRuleContext {
+    BY(): TerminalNode;
+    fieldName(): FieldNameContext | undefined;
+    fieldExpr(): FieldExprContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class TopStatementContext extends ParserRuleContext {
+    TOP(): TerminalNode;
+    INTEGER_LITERAL(): TerminalNode;
+    bySpec(): BySpecContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class IndexElementContext extends ParserRuleContext {
+    fieldPath(): FieldPathContext | undefined;
+    DOT(): TerminalNode | undefined;
+    STAR(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class IndexFieldsContext extends ParserRuleContext {
+    indexElement(): IndexElementContext[];
+    indexElement(i: number): IndexElementContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class IndexStatementContext extends ParserRuleContext {
+    INDEX(): TerminalNode;
+    indexFields(): IndexFieldsContext;
+    BY(): TerminalNode | undefined;
+    fieldName(): FieldNameContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SampleStatementContext extends ParserRuleContext {
+    SAMPLE(): TerminalNode;
+    sampleSpec(): SampleSpecContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SampleSpecContext extends ParserRuleContext {
+    PERCENT_LITERAL(): TerminalNode | undefined;
+    INTEGER_LITERAL(): TerminalNode | undefined;
+    TRUE(): TerminalNode | undefined;
+    FALSE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class AggregateContext extends ParserRuleContext {
+    SUM(): TerminalNode | undefined;
+    COUNT(): TerminalNode | undefined;
+    AVG(): TerminalNode | undefined;
+    MIN(): TerminalNode | undefined;
+    MAX(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class MalloyTypeContext extends ParserRuleContext {
+    STRING(): TerminalNode | undefined;
+    NUMBER(): TerminalNode | undefined;
+    BOOLEAN(): TerminalNode | undefined;
+    DATE(): TerminalNode | undefined;
+    TIMESTAMP(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class CompareOpContext extends ParserRuleContext {
+    MATCH(): TerminalNode | undefined;
+    NOT_MATCH(): TerminalNode | undefined;
+    GT(): TerminalNode | undefined;
+    LT(): TerminalNode | undefined;
+    GTE(): TerminalNode | undefined;
+    LTE(): TerminalNode | undefined;
+    EQ(): TerminalNode | undefined;
+    NE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class LiteralContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: LiteralContext): void;
+}
+export declare class ExprStringContext extends LiteralContext {
+    STRING_LITERAL(): TerminalNode;
+    constructor(ctx: LiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprNumberContext extends LiteralContext {
+    NUMERIC_LITERAL(): TerminalNode | undefined;
+    INTEGER_LITERAL(): TerminalNode | undefined;
+    constructor(ctx: LiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprTimeContext extends LiteralContext {
+    dateLiteral(): DateLiteralContext;
+    constructor(ctx: LiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprNULLContext extends LiteralContext {
+    NULL(): TerminalNode;
+    constructor(ctx: LiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprBoolContext extends LiteralContext {
+    TRUE(): TerminalNode | undefined;
+    FALSE(): TerminalNode | undefined;
+    constructor(ctx: LiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprRegexContext extends LiteralContext {
+    HACKY_REGEX(): TerminalNode;
+    constructor(ctx: LiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprNowContext extends LiteralContext {
+    NOW(): TerminalNode;
+    constructor(ctx: LiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class DateLiteralContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: DateLiteralContext): void;
+}
+export declare class LiteralTimestampContext extends DateLiteralContext {
+    LITERAL_TIMESTAMP(): TerminalNode;
+    constructor(ctx: DateLiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class LiteralDayContext extends DateLiteralContext {
+    LITERAL_DAY(): TerminalNode;
+    constructor(ctx: DateLiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class LiteralWeekContext extends DateLiteralContext {
+    LITERAL_WEEK(): TerminalNode;
+    constructor(ctx: DateLiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class LiteralMonthContext extends DateLiteralContext {
+    LITERAL_MONTH(): TerminalNode;
+    constructor(ctx: DateLiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class LiteralQuarterContext extends DateLiteralContext {
+    LITERAL_QUARTER(): TerminalNode;
+    constructor(ctx: DateLiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class LiteralYearContext extends DateLiteralContext {
+    LITERAL_YEAR(): TerminalNode;
+    constructor(ctx: DateLiteralContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class TableNameContext extends ParserRuleContext {
+    STRING_LITERAL(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class IdContext extends ParserRuleContext {
+    IDENTIFIER(): TerminalNode | undefined;
+    OBJECT_NAME_LITERAL(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class TimeframeContext extends ParserRuleContext {
+    SECOND(): TerminalNode | undefined;
+    MINUTE(): TerminalNode | undefined;
+    HOUR(): TerminalNode | undefined;
+    DAY(): TerminalNode | undefined;
+    WEEK(): TerminalNode | undefined;
+    MONTH(): TerminalNode | undefined;
+    QUARTER(): TerminalNode | undefined;
+    YEAR(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class UngroupContext extends ParserRuleContext {
+    ALL(): TerminalNode | undefined;
+    EXCLUDE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FieldExprContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: FieldExprContext): void;
+}
+export declare class ExprFieldPathContext extends FieldExprContext {
+    fieldPath(): FieldPathContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprFilterContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext;
+    OCURLY(): TerminalNode;
+    filteredBy(): FilteredByContext;
+    CCURLY(): TerminalNode;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprLiteralContext extends FieldExprContext {
+    literal(): LiteralContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprMinusContext extends FieldExprContext {
+    MINUS(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprDurationContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext;
+    timeframe(): TimeframeContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprTimeTruncContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext;
+    DOT(): TerminalNode;
+    timeframe(): TimeframeContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprSafeCastContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext;
+    DOUBLECOLON(): TerminalNode;
+    malloyType(): MalloyTypeContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprMulDivContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    STAR(): TerminalNode | undefined;
+    SLASH(): TerminalNode | undefined;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprAddSubContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    PLUS(): TerminalNode | undefined;
+    MINUS(): TerminalNode | undefined;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprRangeContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    TO(): TerminalNode;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprForRangeContext extends FieldExprContext {
+    _startAt: FieldExprContext;
+    _duration: FieldExprContext;
+    FOR(): TerminalNode;
+    timeframe(): TimeframeContext;
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprLogicalTreeContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext;
+    partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
+    AMPER(): TerminalNode | undefined;
+    BAR(): TerminalNode | undefined;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprCompareContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    compareOp(): CompareOpContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprApplyContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext;
+    partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
+    COLON(): TerminalNode | undefined;
+    QMARK(): TerminalNode | undefined;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprNotContext extends FieldExprContext {
+    NOT(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprLogicalContext extends FieldExprContext {
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    AND(): TerminalNode | undefined;
+    OR(): TerminalNode | undefined;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprCastContext extends FieldExprContext {
+    CAST(): TerminalNode;
+    OPAREN(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    AS(): TerminalNode;
+    malloyType(): MalloyTypeContext;
+    CPAREN(): TerminalNode;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprCountDisinctContext extends FieldExprContext {
+    COUNT(): TerminalNode;
+    OPAREN(): TerminalNode;
+    DISTINCT(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    CPAREN(): TerminalNode;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprAggregateContext extends FieldExprContext {
+    aggregate(): AggregateContext;
+    OPAREN(): TerminalNode;
+    CPAREN(): TerminalNode;
+    fieldPath(): FieldPathContext | undefined;
+    DOT(): TerminalNode | undefined;
+    fieldExpr(): FieldExprContext | undefined;
+    STAR(): TerminalNode | undefined;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprExprContext extends FieldExprContext {
+    OPAREN(): TerminalNode;
+    partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
+    CPAREN(): TerminalNode;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprFuncContext extends FieldExprContext {
+    OPAREN(): TerminalNode;
+    CPAREN(): TerminalNode;
+    id(): IdContext | undefined;
+    timeframe(): TimeframeContext | undefined;
+    argumentList(): ArgumentListContext | undefined;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprPickContext extends FieldExprContext {
+    pickStatement(): PickStatementContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprUngroupContext extends FieldExprContext {
+    ungroup(): UngroupContext;
+    OPAREN(): TerminalNode;
+    fieldExpr(): FieldExprContext;
+    CPAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    fieldName(): FieldNameContext[];
+    fieldName(i: number): FieldNameContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class PartialAllowedFieldExprContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: PartialAllowedFieldExprContext): void;
+}
+export declare class ExprPartialCompareContext extends PartialAllowedFieldExprContext {
+    compareOp(): CompareOpContext;
+    fieldExpr(): FieldExprContext;
+    constructor(ctx: PartialAllowedFieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ExprNotPartialContext extends PartialAllowedFieldExprContext {
+    fieldExpr(): FieldExprContext;
+    constructor(ctx: PartialAllowedFieldExprContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class PickStatementContext extends ParserRuleContext {
+    _pickElse: FieldExprContext;
+    pick(): PickContext[];
+    pick(i: number): PickContext;
+    ELSE(): TerminalNode | undefined;
+    fieldExpr(): FieldExprContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class PickContext extends ParserRuleContext {
+    _pickValue: FieldExprContext;
+    _pickWhen: PartialAllowedFieldExprContext;
+    PICK(): TerminalNode;
+    WHEN(): TerminalNode;
+    partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
+    fieldExpr(): FieldExprContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ArgumentListContext extends ParserRuleContext {
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FieldNameListContext extends ParserRuleContext {
+    fieldName(): FieldNameContext[];
+    fieldName(i: number): FieldNameContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FieldCollectionContext extends ParserRuleContext {
+    collectionMember(): CollectionMemberContext[];
+    collectionMember(i: number): CollectionMemberContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class CollectionMemberContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: CollectionMemberContext): void;
+}
+export declare class NameMemberContext extends CollectionMemberContext {
+    fieldPath(): FieldPathContext;
+    constructor(ctx: CollectionMemberContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class WildMemberContext extends CollectionMemberContext {
+    STAR(): TerminalNode | undefined;
+    STARSTAR(): TerminalNode | undefined;
+    fieldPath(): FieldPathContext | undefined;
+    DOT(): TerminalNode | undefined;
+    constructor(ctx: CollectionMemberContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class NewMemberContext extends CollectionMemberContext {
+    fieldDef(): FieldDefContext;
+    constructor(ctx: CollectionMemberContext);
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FieldPathContext extends ParserRuleContext {
+    fieldName(): FieldNameContext[];
+    fieldName(i: number): FieldNameContext;
+    DOT(): TerminalNode[];
+    DOT(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JoinNameContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class FieldNameContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JustExprContext extends ParserRuleContext {
+    fieldExpr(): FieldExprContext;
+    EOF(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JsonContext extends ParserRuleContext {
+    jsonValue(): JsonValueContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JsonValueContext extends ParserRuleContext {
+    JSON_STRING(): TerminalNode | undefined;
+    INTEGER_LITERAL(): TerminalNode | undefined;
+    NUMERIC_LITERAL(): TerminalNode | undefined;
+    jsonObject(): JsonObjectContext | undefined;
+    jsonArray(): JsonArrayContext | undefined;
+    TRUE(): TerminalNode | undefined;
+    FALSE(): TerminalNode | undefined;
+    NULL(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JsonObjectContext extends ParserRuleContext {
+    OCURLY(): TerminalNode;
+    jsonProperty(): JsonPropertyContext[];
+    jsonProperty(i: number): JsonPropertyContext;
+    CCURLY(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JsonPropertyContext extends ParserRuleContext {
+    JSON_STRING(): TerminalNode;
+    COLON(): TerminalNode;
+    jsonValue(): JsonValueContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class JsonArrayContext extends ParserRuleContext {
+    OBRACK(): TerminalNode;
+    jsonValue(): JsonValueContext[];
+    jsonValue(i: number): JsonValueContext;
+    CBRACK(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SqlBlockContext extends ParserRuleContext {
+    SQL_STRING(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SqlExploreNameRefContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class SqlCommandNameDefContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}
+export declare class ConnectionNameContext extends ParserRuleContext {
+    JSON_STRING(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyListener): void;
+    exitRule(listener: MalloyListener): void;
+    accept<Result>(visitor: MalloyVisitor<Result>): Result;
+}