@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

package/dist/lang/ast/ast-main.d.ts

@@ -1,416 +1,28 @@
 import * as model from "../../model/malloy_types";
-import { Dialect } from "../../dialect/dialect";
-import { AtomicFieldType, ExpressionType, FieldTypeDef, Fragment, TimeFieldType, TimestampUnit } from "../../model/malloy_types";
-import { MalloyTranslation, ModelDataRequest } from "../parse-malloy";
-import { Comparison, ExprValue, FieldValueType } from "./ast-types";
-export declare class ErrorFactory {
-    static get structDef(): model.StructDef;
-    static isErrorStructDef(s: model.StructDef): boolean;
-    static get query(): model.Query;
-    static get reduceSegment(): model.ReduceSegment;
-    static get projectSegment(): model.ProjectSegment;
-    static get indexSegment(): model.IndexSegment;
-}
-declare type ChildBody = MalloyElement | MalloyElement[];
-declare type ElementChildren = Record<string, ChildBody>;
-export declare abstract class MalloyElement {
-    abstract elementType: string;
-    codeLocation?: model.DocumentLocation;
-    children: ElementChildren;
-    parent: MalloyElement | null;
-    private logger?;
-    /**
-     * @param kids All children passed to the constructor are not optional
-     */
-    constructor(kids?: ElementChildren);
-    /**
-     * Record all elements as children of this element, and mark this
-     * element as their parent.
-     * @param kids Some of these might be undefined, in which case they are ignored
-     */
-    has(kids: Record<string, ChildBody | undefined>): void;
-    get location(): model.DocumentLocation;
-    set location(loc: model.DocumentLocation | undefined);
-    protected namespace(): NameSpace | undefined;
-    modelEntry(reference: string | ModelEntryReference): ModelEntry | undefined;
-    private xlate?;
-    translator(): MalloyTranslation | undefined;
-    setTranslator(x: MalloyTranslation): void;
-    addReference(reference: model.DocumentReference): void;
-    private get sourceURL();
-    errorsExist(): boolean;
-    private logged;
-    log(message: string): void;
-    /**
-     * Mostly for debugging / testing. A string-y version of this object which
-     * is used to ask "are these two AST segments equal". Formatted so that
-     * errors would be human readable.
-     * @param indent only used for recursion
-     */
-    toString(): string;
-    private stringify;
-    walk(callBack: (node: MalloyElement) => void): void;
-    private varInfo;
-    protected internalError(msg: string): Error;
-}
-export declare class ListOf<ET extends MalloyElement> extends MalloyElement {
-    elementType: string;
-    protected elements: ET[];
-    constructor(listDesc: string, elements: ET[]);
-    private newContents;
-    get list(): ET[];
-    empty(): boolean;
-    notEmpty(): boolean;
-    push(...el: ET[]): ET[];
-}
-export declare class Unimplemented extends MalloyElement {
-    elementType: string;
-    reported: boolean;
-}
-declare type FieldDecl = FieldDeclaration | Join | TurtleDecl | Turtles;
-export declare type ExploreField = FieldDecl | RenameField;
-export declare function isExploreField(f: MalloyElement): f is ExploreField;
-/**
- * A "Mallobj" is a thing which you can run queries against, it has been called
- * an "exploreable", or a "space".
- */
-export declare abstract class Mallobj extends MalloyElement {
-    abstract structDef(): model.StructDef;
-    structRef(): model.StructRef;
-    withParameters(pList: HasParameter[] | undefined): model.StructDef;
-}
-export interface DocStatement extends MalloyElement {
-    execute(doc: Document): ModelDataRequest;
-}
-export declare class RunList extends ListOf<DocStatement> {
-    execCursor: number;
-    executeList(doc: Document): ModelDataRequest;
-}
-export declare function isDocStatement(e: MalloyElement): e is DocStatement;
-export declare class DefineExplore extends MalloyElement implements DocStatement {
-    readonly name: string;
-    readonly mallobj: Mallobj;
-    readonly exported: boolean;
-    elementType: string;
-    readonly parameters?: HasParameter[];
-    constructor(name: string, mallobj: Mallobj, exported: boolean, params?: MalloyElement[]);
-    execute(doc: Document): ModelDataRequest;
-}
-export declare class DefineSourceList extends RunList implements DocStatement {
-    constructor(sourceList: DefineExplore[]);
-    execute(doc: Document): ModelDataRequest;
-}
-/**
- * A Mallobj made from a source and a set of refinements
- */
-export declare class RefinedExplore extends Mallobj {
-    readonly source: Mallobj;
-    readonly refinement: ExploreDesc;
-    elementType: string;
-    constructor(source: Mallobj, refinement: ExploreDesc);
-    structDef(): model.StructDef;
-    withParameters(pList: HasParameter[] | undefined): model.StructDef;
-}
-export declare class TableSource extends Mallobj {
-    readonly name: string;
-    elementType: string;
-    constructor(name: string);
-    structDef(): model.StructDef;
-}
-export declare class IsValueBlock extends MalloyElement {
-    readonly isMap: Record<string, ConstantSubExpression>;
-    elementType: string;
-    constructor(isMap: Record<string, ConstantSubExpression>);
-}
-export declare class ModelEntryReference extends MalloyElement {
-    readonly name: string;
-    elementType: string;
-    constructor(name: string);
-    get refString(): string;
-    toString(): string;
-}
-export declare class NamedSource extends Mallobj {
-    readonly ref: ModelEntryReference | string;
-    elementType: string;
-    protected isBlock?: IsValueBlock;
-    constructor(ref: ModelEntryReference | string, paramValues?: Record<string, ConstantSubExpression>);
-    get refName(): string;
-    structRef(): model.StructRef;
-    modelStruct(): model.StructDef | undefined;
-    structDef(): model.StructDef;
-}
-export declare class SQLSource extends NamedSource {
-    elementType: string;
-    structRef(): model.StructRef;
-    modelStruct(): model.StructDef | undefined;
-}
-export declare class QuerySource extends Mallobj {
-    readonly query: QueryElement;
-    elementType: string;
-    constructor(query: QueryElement);
-    structDef(): model.StructDef;
-}
-export declare abstract class Join extends MalloyElement {
-    abstract name: ModelEntryReference;
-    abstract structDef(): model.StructDef;
-    abstract fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): void;
-}
-export declare class KeyJoin extends Join {
-    readonly name: ModelEntryReference;
-    readonly source: Mallobj;
-    readonly keyExpr: ExpressionDef;
-    elementType: string;
-    constructor(name: ModelEntryReference, source: Mallobj, keyExpr: ExpressionDef);
-    structDef(): model.StructDef;
-    fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): void;
-}
-declare type ExpressionJoinType = "many" | "one" | "cross";
-export declare class ExpressionJoin extends Join {
-    readonly name: ModelEntryReference;
-    readonly source: Mallobj;
-    elementType: string;
-    joinType: ExpressionJoinType;
-    private expr?;
-    constructor(name: ModelEntryReference, source: Mallobj);
-    set joinOn(joinExpr: ExpressionDef | undefined);
-    get joinOn(): ExpressionDef | undefined;
-    fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): model.Expr | undefined;
-    structDef(): model.StructDef;
-}
-export declare class Joins extends ListOf<Join> {
-    constructor(joins: Join[]);
-}
-export declare type QueryProperty = Ordering | Top | Limit | Filter | Index | SampleProperty | Joins | DeclareFields | ProjectStatement | NestReference | NestDefinition | NestReference | Nests | Aggregate | GroupBy;
-export declare function isQueryProperty(q: MalloyElement): q is QueryProperty;
-export declare type ExploreProperty = Filter | Joins | DeclareFields | FieldListEdit | Renames | PrimaryKey | Turtles;
-export declare function isExploreProperty(p: MalloyElement): p is ExploreProperty;
-export declare class ExploreDesc extends ListOf<ExploreProperty> {
-    constructor(props: ExploreProperty[]);
-}
-export declare class FilterElement extends MalloyElement {
-    readonly expr: ExpressionDef;
-    readonly exprSrc: string;
-    elementType: string;
-    constructor(expr: ExpressionDef, exprSrc: string);
-    filterExpression(fs: FieldSpace): model.FilterExpression;
-}
-export declare class Filter extends ListOf<FilterElement> {
-    elementType: string;
-    private havingClause?;
-    constructor(elements?: FilterElement[]);
-    set having(isHaving: boolean);
-    getFilterList(fs: FieldSpace): model.FilterExpression[];
-}
-export declare class DeclareFields extends ListOf<FieldDeclaration> {
-    constructor(fields: FieldDeclaration[], fieldType?: string);
-}
-export declare class Measures extends DeclareFields {
-    constructor(measures: FieldDeclaration[]);
-}
-export declare class Dimensions extends DeclareFields {
-    constructor(dimensions: FieldDeclaration[]);
-}
-export declare class Renames extends ListOf<RenameField> {
-    constructor(renames: RenameField[]);
-}
-export declare class FieldName extends MalloyElement {
-    readonly name: string;
-    elementType: string;
-    constructor(name: string);
-    get refString(): string;
-    toString(): string;
-    getField(fs: FieldSpace): LookupResult;
-}
-export declare class FieldReference extends ListOf<FieldName> {
-    elementType: string;
-    constructor(names: FieldName[]);
-    get refString(): string;
-    get outputName(): string;
-    get sourceString(): string | undefined;
-    get nameString(): string;
-    getField(fs: FieldSpace): LookupResult;
-}
-export declare type FieldReferenceElement = FieldReference | WildcardFieldReference;
-export declare class FieldReferences extends ListOf<FieldReferenceElement> {
-    constructor(members: FieldReferenceElement[]);
-}
-export declare type FieldCollectionMember = FieldReferenceElement | FieldDeclaration;
-export declare function isFieldCollectionMember(el: MalloyElement): el is FieldCollectionMember;
-export declare class ProjectStatement extends ListOf<FieldCollectionMember> {
-    constructor(members: FieldCollectionMember[]);
-}
-export declare class FieldListEdit extends MalloyElement {
-    readonly edit: "accept" | "except";
-    readonly refs: FieldReferences;
-    elementType: string;
-    constructor(edit: "accept" | "except", refs: FieldReferences);
-}
-export declare type QueryItem = FieldDeclaration | FieldReference | NestDefinition | NestReference;
-export declare class GroupBy extends ListOf<QueryItem> {
-    constructor(members: QueryItem[]);
-}
-export declare class Aggregate extends ListOf<QueryItem> {
-    constructor(members: QueryItem[]);
-}
-interface OpDesc {
-    segment: model.PipeSegment;
-    outputSpace: () => FieldSpace;
-}
-declare type QOPType = "grouping" | "aggregate" | "project" | "index";
-export declare class QOPDesc extends ListOf<QueryProperty> {
-    opType: QOPType;
-    private refineThis?;
-    constructor(props: QueryProperty[]);
-    protected computeType(): QOPType;
-    refineFrom(existing: model.PipeSegment): void;
-    private getExecutor;
-    getOp(inputFS: FieldSpace, forPipeline: PipelineDesc | null): OpDesc;
-}
-export interface ModelEntry {
-    entry: model.NamedModelObject;
-    exported?: boolean;
-    sqlType?: boolean;
-}
-export interface NameSpace {
-    getEntry(name: string): ModelEntry | undefined;
-    setEntry(name: string, value: ModelEntry, exported: boolean): void;
-}
-interface DocumentCompileResult {
-    modelDef: model.ModelDef;
-    queryList: model.Query[];
-    sqlBlocks: model.SQLBlockStructDef[];
-    needs: ModelDataRequest;
-}
-/**
- * The Document class is a little weird because we might need to bounce back
- * to the requestor, which might be on the other side of a wire, to get
- * back some schema information. The intended translation of a Document
- * is to call initModelDef(), and then to call modelDataRequest() until it
- * returns undefined. At any time you can call modelDef to get the model
- * as it exists so far, but the translation is not complete until
- * modelDataRequest() returns undefined;
- *
- * TODO probably modelRequest should be the method and you call it
- * until it returns a model with no additional data needed ...
- * that can be tomorrow
- */
-export declare class Document extends MalloyElement implements NameSpace {
-    elementType: string;
-    documentModel: Record<string, ModelEntry>;
-    queryList: model.Query[];
-    sqlBlocks: model.SQLBlockStructDef[];
-    statements: RunList;
-    didInitModel: boolean;
-    constructor(statements: DocStatement[]);
-    initModelDef(extendingModelDef: model.ModelDef | undefined): void;
-    compile(): DocumentCompileResult;
-    modelDef(): model.ModelDef;
-    defineSQL(sql: model.SQLBlockStructDef, name?: string): boolean;
-    getEntry(str: string): ModelEntry;
-    setEntry(str: string, ent: ModelEntry): void;
-}
-export declare class PrimaryKey extends MalloyElement {
-    readonly field: FieldName;
-    elementType: string;
-    constructor(field: FieldName);
-}
-export declare class RenameField extends MalloyElement {
-    readonly newName: string;
-    readonly oldName: FieldName;
-    elementType: string;
-    constructor(newName: string, oldName: FieldName);
-}
-export declare class WildcardFieldReference extends MalloyElement {
-    readonly joinPath: FieldReference | undefined;
-    readonly star: "*" | "**";
-    elementType: string;
-    constructor(joinPath: FieldReference | undefined, star: "*" | "**");
-    getFieldDef(): model.FieldDef;
-    get refString(): string;
-}
-export declare class OrderBy extends MalloyElement {
-    readonly field: number | FieldName;
-    readonly dir?: "asc" | "desc" | undefined;
-    elementType: string;
-    constructor(field: number | FieldName, dir?: "asc" | "desc" | undefined);
-    get modelField(): string | number;
-    getOrderBy(_fs: FieldSpace): model.OrderBy;
-}
-export declare class Ordering extends ListOf<OrderBy> {
-    constructor(list: OrderBy[]);
-    getOrderBy(fs: FieldSpace): model.OrderBy[];
-}
-export declare class Limit extends MalloyElement {
-    readonly limit: number;
-    elementType: string;
-    constructor(limit: number);
-}
-export declare class Turtles extends ListOf<TurtleDecl> {
-    constructor(turtles: TurtleDecl[]);
-}
-export declare class Index extends MalloyElement {
-    readonly fields: FieldReferences;
-    elementType: string;
-    weightBy?: FieldName;
-    constructor(fields: FieldReferences);
-    useWeight(fn: FieldName): void;
-}
-interface QueryComp {
-    outputStruct: model.StructDef;
-    query: model.Query;
-}
-/**
- * Generic abstract for all pipelines, the first segment might be a reference
- * to an existing pipeline (query or turtle), and if there is a refinement it
- * is refers to the first segment of the composed pipeline.
- */
-declare abstract class PipelineDesc extends MalloyElement {
-    elementType: string;
-    protected headRefinement?: QOPDesc;
-    protected qops: QOPDesc[];
-    nestedInQuerySpace?: QuerySpace;
-    refineHead(refinement: QOPDesc): void;
-    addSegments(...segDesc: QOPDesc[]): void;
-    protected appendOps(modelPipe: model.PipeSegment[], existingEndSpace: FieldSpace): {
-        opList: model.PipeSegment[];
-        structDef: model.StructDef;
-    };
-    protected refinePipeline(fs: FieldSpace, modelPipe: model.Pipeline): model.Pipeline;
-    protected expandTurtle(turtleName: string, fromStruct: model.StructDef): {
-        pipeline: model.PipeSegment[];
-        location: model.DocumentLocation | undefined;
-    };
-    protected getOutputStruct(walkStruct: model.StructDef, pipeline: model.PipeSegment[]): model.StructDef;
-}
-export declare class ExistingQuery extends PipelineDesc {
-    _head?: ModelEntryReference;
-    set head(head: ModelEntryReference | undefined);
-    get head(): ModelEntryReference | undefined;
-    queryComp(): QueryComp;
-    query(): model.Query;
-}
-export declare abstract class TurtleHeadedPipe extends PipelineDesc {
-    _turtleName?: FieldName;
-    set turtleName(turtleName: FieldName | undefined);
-    get turtleName(): FieldName | undefined;
-}
-export declare class FullQuery extends TurtleHeadedPipe {
-    readonly explore: Mallobj;
-    constructor(explore: Mallobj);
-    queryComp(): QueryComp;
-    query(): model.Query;
-}
+import { SpaceEntry } from "./types/space-entry";
+import { ExploreField } from "./types/explore-field";
+import { NestedQuery } from "./types/nested-query";
+import { QueryItem } from "./types/query-item";
+import { FieldListEdit } from "./explore-properties/field-list-edit";
+import { FieldCollectionMember } from "./types/field-collection-member";
+import { FieldDeclaration } from "./query-items/field-declaration";
+import { FieldReference, WildcardFieldReference } from "./query-items/field-references";
+import { FieldName, FieldSpace, SourceSpec } from "./types/field-space";
+import { HasParameter } from "./parameters/has-parameter";
+import { MalloyElement } from "./types/malloy-element";
+import { Join } from "./query-properties/joins";
+import { SpaceField } from "./types/space-field";
+import { QueryField } from "./space-fields/query-space-field";
+import { SpaceSeed } from "./space-seed";
+import { StaticSpace } from "./static-space";
+import { TurtleHeadedPipe } from "./types/turtle-headed-pipe";
+import { FieldType } from "./types/field-type";
 export declare class TurtleDecl extends TurtleHeadedPipe {
     readonly name: string;
     constructor(name: string);
     getPipeline(fs: FieldSpace): model.Pipeline;
     getFieldDef(fs: FieldSpace, nestParent: QuerySpace | undefined): model.TurtleDef;
 }
-export declare class NestReference extends FieldReference {
-    readonly name: FieldName;
-    elementType: string;
-    constructor(name: FieldName);
-}
 export declare class NestRefinement extends TurtleDecl {
     elementType: string;
     constructor(turtleName: FieldName);
@@ -419,290 +31,7 @@ export declare class NestDefinition extends TurtleDecl {
     elementType: string;
     constructor(name: string);
 }
-export declare type NestedQuery = NestReference | NestDefinition | NestRefinement;
 export declare function isNestedQuery(me: MalloyElement): me is NestedQuery;
-export declare class Nests extends ListOf<NestedQuery> {
-    constructor(nests: NestedQuery[]);
-}
-export declare type QueryElement = FullQuery | ExistingQuery;
-export declare function isQueryElement(e: MalloyElement): e is QueryElement;
-export declare class DefineQueryList extends RunList implements DocStatement {
-    constructor(queryList: DefineQuery[]);
-    execute(doc: Document): ModelDataRequest;
-}
-export declare class DefineQuery extends MalloyElement implements DocStatement {
-    readonly name: string;
-    readonly queryDetails: QueryElement;
-    elementType: string;
-    constructor(name: string, queryDetails: QueryElement);
-    execute(doc: Document): ModelDataRequest;
-}
-export declare class AnonymousQuery extends MalloyElement implements DocStatement {
-    readonly theQuery: QueryElement;
-    elementType: string;
-    constructor(theQuery: QueryElement);
-    execute(doc: Document): ModelDataRequest;
-}
-declare type TopInit = FieldName | ExpressionDef;
-export declare class Top extends MalloyElement {
-    readonly limit: number;
-    readonly by?: TopInit | undefined;
-    elementType: string;
-    constructor(limit: number, by?: TopInit | undefined);
-    getBy(fs: FieldSpace): model.By | undefined;
-}
-export declare class JSONElement extends MalloyElement {
-    elementType: string;
-    readonly value: any;
-    constructor(jsonSrc: string);
-}
-export declare class JSONStructDef extends Mallobj {
-    readonly struct: model.StructDef;
-    elementType: string;
-    constructor(struct: model.StructDef);
-    static fromJSON(jsonObj: JSONElement): JSONStructDef | undefined;
-    structDef(): model.StructDef;
-}
-export declare class ImportStatement extends MalloyElement implements DocStatement {
-    readonly url: string;
-    elementType: string;
-    fullURL?: string;
-    constructor(url: string, baseURL: string);
-    execute(doc: Document): ModelDataRequest;
-}
-interface HasInit {
-    name: string;
-    isCondition: boolean;
-    type?: string;
-    default?: ConstantSubExpression;
-}
-export declare class HasParameter extends MalloyElement {
-    elementType: string;
-    readonly name: string;
-    readonly isCondition: boolean;
-    readonly type?: model.AtomicFieldType;
-    readonly default?: ConstantSubExpression;
-    constructor(init: HasInit);
-    parameter(): model.Parameter;
-}
-export declare class ConstantParameter extends HasParameter {
-    readonly value: ConstantSubExpression;
-    constructor(name: string, value: ConstantSubExpression);
-    parameter(): model.Parameter;
-}
-declare type SQLStringSegment = string | QueryElement;
-export declare class SQLString extends MalloyElement {
-    elementType: string;
-    elements: SQLStringSegment[];
-    containsQueries: boolean;
-    push(el: string | MalloyElement): void;
-    sqlPhrases(): model.SQLPhrase[];
-}
-export declare class SQLStatement extends MalloyElement implements DocStatement {
-    readonly select: SQLString;
-    elementType: string;
-    is?: string;
-    connection?: string;
-    requestBlock?: model.SQLBlockSource;
-    constructor(select: SQLString);
-    sqlBlock(): model.SQLBlockSource;
-    /**
-     * This is the one statement which pauses execution. First time through
-     * it will generate a schema request, next time through it will either
-     * record the error or record the schema.
-     */
-    execute(doc: Document): ModelDataRequest;
-}
-export declare class SampleProperty extends MalloyElement {
-    readonly sample: model.Sampling;
-    elementType: string;
-    constructor(sample: model.Sampling);
-    sampling(): model.Sampling;
-}
-/**
- * Root node for any element in an expression. These essentially
- * create a sub-tree in the larger AST. Expression nodes know
- * how to write themselves as SQL (or rather, generate the
- * template for SQL required by the query writer)
- */
-export declare abstract class ExpressionDef extends MalloyElement {
-    abstract elementType: string;
-    granular(): boolean;
-    /**
-     * Returns the "translation" or template for SQL generation. When asking
-     * for a tranlsation you may pass the types you can accept, allowing
-     * the translation code a chance to convert to match your expectations
-     * @param space Namespace for looking up field references
-     */
-    abstract getExpression(fs: FieldSpace): ExprValue;
-    legalChildTypes: import("./ast-types").FragType[];
-    /**
-     * Some operators want to give the right hand value a chance to
-     * rewrite itself. This requests a translation for a rewrite,
-     * or returns undefined if that request should be denied.
-     * @param fs FieldSpace
-     * @returns Translated expression or undefined
-     */
-    requestExpression(fs: FieldSpace): ExprValue | undefined;
-    defaultFieldName(): string | undefined;
-    /**
-     * Check an expression for type compatibility
-     * @param _eNode currently unused, will be used to get error location
-     * @param eVal ...list of expressions that must match legalChildTypes
-     */
-    typeCheck(eNode: ExpressionDef, eVal: ExprValue): boolean;
-    /**
-     * This is the operation which makes partial comparison and value trees work
-     * The default implemention merely constructs LEFT OP RIGHT, but specialized
-     * nodes like alternation trees or or partial comparison can control how
-     * the appplication gets generated
-     * @param fs The symbol table
-     * @param op The operator being applied
-     * @param expr The "other" (besdies 'this') value
-     * @returns The translated expression
-     */
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-}
-export declare class ConstantSubExpression extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    elementType: string;
-    private cfs?;
-    constructor(expr: ExpressionDef);
-    getExpression(_fs: FieldSpace): ExprValue;
-    private get constantFs();
-    constantValue(): ExprValue;
-    constantCondition(type: AtomicFieldType): ExprValue;
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(fs: FieldSpace): ExprValue | undefined;
-}
-export declare class FieldDeclaration extends MalloyElement {
-    readonly expr: ExpressionDef;
-    readonly defineName: string;
-    readonly exprSrc?: string | undefined;
-    elementType: string;
-    isMeasure?: boolean;
-    constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
-    fieldDef(fs: FieldSpace, exprName: string): FieldTypeDef;
-    queryFieldDef(exprFS: FieldSpace, exprName: string): FieldTypeDef;
-}
-/**
- * All of the magic of malloy expressions eventually flows to here,
- * where an operator is applied to two values. Depending on the
- * operator and value types this may involve transformations of
- * the values or even the operator.
- * @param fs FieldSpace for the symbols
- * @param left Left value
- * @param op The operator
- * @param right Right Value
- * @returns ExprValue of the expression
- */
-export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
-export declare abstract class BinaryBoolean<opType extends string> extends ExpressionDef {
-    readonly left: ExpressionDef;
-    readonly op: opType;
-    readonly right: ExpressionDef;
-    elementType: string;
-    legalChildTypes: import("./ast-types").FragType[];
-    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class ExprCompare extends BinaryBoolean<Comparison> {
-    elementType: string;
-    constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-/**
- * GranularTime is a moment in time which ALSO has a "granularity"
- * commonly this are created by applying ".datePart" to an expression
- * 1) They have a value, which is the moment in time
- * 2) When used in a comparison, they act like a range, for the
- *    duration of 1 unit of granularity
- */
-export declare class ExprGranularTime extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    readonly units: TimestampUnit;
-    readonly truncate: boolean;
-    elementType: string;
-    legalChildTypes: import("./ast-types").FragType[];
-    constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
-    granular(): boolean;
-    getExpression(fs: FieldSpace): ExprValue;
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-    protected timestampRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    protected dateRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-}
-export declare class TypeMistmatch extends Error {
-}
-export declare class ExprDuration extends ExpressionDef {
-    readonly n: ExpressionDef;
-    readonly timeframe: TimestampUnit;
-    elementType: string;
-    legalChildTypes: import("./ast-types").FragType[];
-    constructor(n: ExpressionDef, timeframe: TimestampUnit);
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-export declare class ExprTime extends ExpressionDef {
-    elementType: string;
-    readonly translationValue: ExprValue;
-    constructor(timeType: TimeFieldType, value: Fragment[] | string, expressionType?: ExpressionType);
-    getExpression(_fs: FieldSpace): ExprValue;
-    static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
-}
-export declare class Range extends ExpressionDef {
-    readonly first: ExpressionDef;
-    readonly last: ExpressionDef;
-    elementType: string;
-    constructor(first: ExpressionDef, last: ExpressionDef);
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-/**
- * A FieldSpace is a hierarchy of namespaces, where the leaf nodes
- * are fields. A FieldSpace can lookup fields, and generate a StructDef
- */
-export interface FieldSpace {
-    type: "fieldSpace";
-    structDef(): model.StructDef;
-    emptyStructDef(): model.StructDef;
-    lookup(symbol: FieldName[]): LookupResult;
-    dialectObj(): Dialect | undefined;
-    whenComplete: (step: () => void) => void;
-}
-/**
- * Used to detect references to fields in the statement which defines them
- */
-export declare class DefSpace implements FieldSpace {
-    readonly realFS: FieldSpace;
-    readonly circular: FieldDeclaration;
-    readonly type = "fieldSpace";
-    foundCircle: boolean;
-    constructor(realFS: FieldSpace, circular: FieldDeclaration);
-    structDef(): model.StructDef;
-    emptyStructDef(): model.StructDef;
-    lookup(symbol: FieldName[]): LookupResult;
-    dialectObj(): Dialect | undefined;
-    whenComplete(step: () => void): void;
-}
-export declare class StaticSpace implements FieldSpace {
-    readonly type = "fieldSpace";
-    private memoMap?;
-    protected fromStruct: model.StructDef;
-    constructor(sourceStructDef: model.StructDef);
-    whenComplete(step: () => void): void;
-    dialectObj(): Dialect | undefined;
-    fromFieldDef(from: model.FieldDef): SpaceField;
-    private get map();
-    protected dropEntries(): void;
-    protected dropEntry(name: string): void;
-    protected entry(name: string): SpaceEntry | undefined;
-    protected setEntry(name: string, value: SpaceEntry): void;
-    protected entries(): [string, SpaceEntry][];
-    structDef(): model.StructDef;
-    emptyStructDef(): model.StructDef;
-    lookup(path: FieldName[]): LookupResult;
-}
 /**
  * A FieldSpace which may undergo modification
  */
@@ -751,90 +80,6 @@ export declare abstract class ResultSpace extends DynamicSpace {
     getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
     getPipeSegment(refineFrom: model.QuerySegment | undefined): model.PipeSegment;
 }
-/**
- * Reduce and project queries use a "QuerySpace"
- */
-export declare class ReduceFieldSpace extends ResultSpace {
-    readonly segmentType = "reduce";
-}
-export declare class ProjectFieldSpace extends ResultSpace {
-    readonly segmentType = "project";
-    canContain(qd: model.QueryFieldDef): boolean;
-}
-export declare abstract class SpaceEntry {
-    abstract type(): FieldType;
-    abstract refType: "field" | "parameter";
-}
-export declare abstract class SpaceField extends SpaceEntry {
-    readonly refType = "field";
-    protected fieldTypeFromFieldDef(def: model.FieldDef): FieldType;
-    getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef | undefined;
-    fieldDef(): model.FieldDef | undefined;
-}
-export interface FieldType {
-    type: FieldValueType;
-    expressionType?: model.ExpressionType;
-}
-export declare class StructSpaceField extends SpaceField {
-    protected sourceDef: model.StructDef;
-    protected space?: FieldSpace;
-    constructor(sourceDef: model.StructDef);
-    get fieldSpace(): FieldSpace;
-    fieldDef(): model.FieldDef;
-    type(): FieldType;
-}
-export declare abstract class QueryField extends SpaceField {
-    protected inSpace: FieldSpace;
-    constructor(inSpace: FieldSpace);
-    abstract getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef | undefined;
-    abstract fieldDef(): model.FieldDef;
-    type(): FieldType;
-}
-export declare class QueryFieldStruct extends QueryField {
-    protected turtleDef: model.TurtleDef;
-    constructor(fs: FieldSpace, turtleDef: model.TurtleDef);
-    rename(name: string): void;
-    fieldDef(): model.TurtleDef;
-    getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef | undefined;
-}
-export declare class ColumnSpaceField extends SpaceField {
-    protected def: model.FieldTypeDef;
-    constructor(def: model.FieldTypeDef);
-    fieldDef(): model.FieldDef;
-    type(): FieldType;
-}
-export declare abstract class SpaceParam extends SpaceEntry {
-    abstract parameter(): model.Parameter;
-    readonly refType = "parameter";
-}
-export declare class DefinedParameter extends SpaceParam {
-    readonly paramDef: model.Parameter;
-    constructor(paramDef: model.Parameter);
-    parameter(): model.Parameter;
-    type(): FieldType;
-}
-/**
- * Based on how things are constructed, the starting field space
- * can either be another field space or an existing structdef.
- * Using a SpaceSeed allows a class to accept either one
- * and use either version at some future time.
- */
-export declare class SpaceSeed {
-    readonly sourceSpec: SourceSpec;
-    private spaceSpec;
-    private asFS?;
-    private asStruct?;
-    constructor(sourceSpec: SourceSpec);
-    get structDef(): model.StructDef;
-    get fieldSpace(): FieldSpace;
-}
-export declare type SourceSpec = model.StructDef | FieldSpace;
-export declare class AbstractParameter extends SpaceParam {
-    readonly astParam: HasParameter;
-    constructor(astParam: HasParameter);
-    parameter(): model.Parameter;
-    type(): FieldType;
-}
 export declare class ExpressionFieldFromAst extends SpaceField {
     readonly space: DynamicSpace;
     readonly exprDef: FieldDeclaration;
@@ -855,19 +100,6 @@ export declare class QueryFieldAST extends QueryField {
     getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef;
     fieldDef(): model.TurtleDef;
 }
-export declare class RenameSpaceField extends SpaceField {
-    private readonly otherField;
-    private readonly newName;
-    private readonly location;
-    constructor(otherField: SpaceField, newName: string, location: model.DocumentLocation);
-    fieldDef(): model.FieldDef | undefined;
-    type(): FieldType;
-}
-export declare class JoinSpaceField extends StructSpaceField {
-    readonly intoFS: FieldSpace;
-    readonly join: Join;
-    constructor(intoFS: FieldSpace, join: Join);
-}
 /**
  * Unlike a source, which is a refinement of a namespace, a query
  * is creating a new unrelated namespace. The query starts with a
@@ -884,32 +116,3 @@ export declare class QuerySpace extends DynamicSpace {
     constructor(input: SourceSpec, result: ResultSpace);
     extendSource(extendField: Join | FieldDeclaration): void;
 }
-export declare class ReferenceField extends SpaceField {
-    readonly fieldRef: FieldReference;
-    constructor(fieldRef: FieldReference);
-    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef | undefined;
-    type(): FieldType;
-}
-export declare class WildSpaceField extends SpaceField {
-    readonly wildText: string;
-    constructor(wildText: string);
-    type(): FieldType;
-    getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef;
-}
-interface LookupFound {
-    found: SpaceEntry;
-    error: undefined;
-}
-interface LookupError {
-    error: string;
-    found: undefined;
-}
-export declare type LookupResult = LookupFound | LookupError;
-export declare class IndexFieldSpace extends ResultSpace {
-    readonly segmentType = "index";
-    fieldList: Set<string>;
-    addReference(ref: FieldReference): void;
-    addWild(wild: WildcardFieldReference): void;
-    getPipeSegment(refineIndex?: model.PipeSegment): model.IndexSegment;
-}
-export {};