@malloydata/malloy 0.0.22-dev230119001546 → 0.0.22-dev230119193053

package/dist/lang/ast/ast-time-expr.d.ts

@@ -1,7 +1,6 @@
 import { TimestampUnit, ExtractUnit, TimeFieldType } from "../../model/malloy_types";
-import { FieldSpace } from "../field-space";
 import { Comparison, ExprValue } from "./ast-types";
-import { ExpressionDef, MalloyElement } from "./ast-main";
+import { ExpressionDef, FieldSpace, MalloyElement } from "./ast-main";
 export declare class Timeframe extends MalloyElement {
     elementType: string;
     readonly text: TimestampUnit;

package/dist/lang/space-field.d.ts

@@ -1,92 +1,5 @@
 import * as model from "../model/malloy_types";
-import { FieldSpace, DynamicSpace, QuerySpace } from "./field-space";
-import { FieldValueType, FieldDeclaration, TurtleDecl, HasParameter, Join, FieldReference } from "./ast";
-interface FieldType {
-    type: FieldValueType;
-    expressionType?: model.ExpressionType;
-}
-export declare abstract class SpaceEntry {
-    abstract type(): FieldType;
-    abstract refType: "field" | "parameter";
-}
-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;
-}
-export declare class AbstractParameter extends SpaceParam {
-    readonly astParam: HasParameter;
-    constructor(astParam: HasParameter);
-    parameter(): model.Parameter;
-    type(): FieldType;
-}
-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 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 WildSpaceField extends SpaceField {
-    readonly wildText: string;
-    constructor(wildText: string);
-    type(): FieldType;
-    getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef;
-}
-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 class JoinSpaceField extends StructSpaceField {
-    readonly intoFS: FieldSpace;
-    readonly join: Join;
-    constructor(intoFS: FieldSpace, join: Join);
-}
-export declare class ColumnSpaceField extends SpaceField {
-    protected def: model.FieldTypeDef;
-    constructor(def: model.FieldTypeDef);
-    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 QueryFieldAST extends QueryField {
-    readonly turtle: TurtleDecl;
-    protected name: string;
-    renameAs?: string;
-    nestParent?: QuerySpace;
-    constructor(fs: FieldSpace, turtle: TurtleDecl, name: string);
-    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef;
-    fieldDef(): model.TurtleDef;
-}
-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;
-}
+import { FieldReference, FieldSpace, FieldType, SpaceField } from "./ast/ast-main";
 /**
  * FilteredAliasedName
  */
@@ -102,21 +15,3 @@ export declare class FANSPaceField extends SpaceField {
     getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef;
     type(): FieldType;
 }
-export declare class ReferenceField extends SpaceField {
-    readonly fieldRef: FieldReference;
-    constructor(fieldRef: FieldReference);
-    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef | undefined;
-    type(): FieldType;
-}
-export declare class ExpressionFieldFromAst extends SpaceField {
-    readonly space: DynamicSpace;
-    readonly exprDef: FieldDeclaration;
-    fieldName: string;
-    defType?: FieldType;
-    constructor(space: DynamicSpace, exprDef: FieldDeclaration);
-    get name(): string;
-    fieldDef(): model.FieldDef;
-    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef;
-    type(): FieldType;
-}
-export {};

package/dist/lang/space-field.js

@@ -45,197 +45,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressionFieldFromAst = exports.ReferenceField = exports.FANSPaceField = exports.QueryFieldStruct = exports.QueryFieldAST = exports.QueryField = exports.ColumnSpaceField = exports.JoinSpaceField = exports.StructSpaceField = exports.WildSpaceField = exports.RenameSpaceField = exports.SpaceField = exports.AbstractParameter = exports.DefinedParameter = exports.SpaceParam = exports.SpaceEntry = void 0;
+exports.FANSPaceField = void 0;
 const model = __importStar(require("../model/malloy_types"));
-const field_space_1 = require("./field-space");
-class SpaceEntry {
-}
-exports.SpaceEntry = SpaceEntry;
-class SpaceParam extends SpaceEntry {
-    constructor() {
-        super(...arguments);
-        this.refType = "parameter";
-    }
-}
-exports.SpaceParam = SpaceParam;
-class DefinedParameter extends SpaceParam {
-    constructor(paramDef) {
-        super();
-        this.paramDef = paramDef;
-    }
-    parameter() {
-        return this.paramDef;
-    }
-    type() {
-        return { type: this.paramDef.type };
-    }
-}
-exports.DefinedParameter = DefinedParameter;
-class AbstractParameter extends SpaceParam {
-    constructor(astParam) {
-        super();
-        this.astParam = astParam;
-    }
-    parameter() {
-        return this.astParam.parameter();
-    }
-    type() {
-        const type = this.astParam.type || "unknown";
-        return { type };
-    }
-}
-exports.AbstractParameter = AbstractParameter;
-class SpaceField extends SpaceEntry {
-    constructor() {
-        super(...arguments);
-        this.refType = "field";
-    }
-    fieldTypeFromFieldDef(def) {
-        const ref = { type: def.type };
-        if (model.isFieldTypeDef(def) && def.expressionType) {
-            ref.expressionType = def.expressionType;
-        }
-        return ref;
-    }
-    getQueryFieldDef(_fs) {
-        return undefined;
-    }
-    fieldDef() {
-        return undefined;
-    }
-}
-exports.SpaceField = SpaceField;
-class RenameSpaceField extends SpaceField {
-    constructor(otherField, newName, location) {
-        super();
-        this.otherField = otherField;
-        this.newName = newName;
-        this.location = location;
-    }
-    fieldDef() {
-        const renamedFieldRaw = this.otherField.fieldDef();
-        if (renamedFieldRaw === undefined) {
-            return undefined;
-        }
-        return {
-            ...renamedFieldRaw,
-            as: this.newName,
-            location: this.location,
-        };
-    }
-    type() {
-        return this.otherField.type();
-    }
-}
-exports.RenameSpaceField = RenameSpaceField;
-class WildSpaceField extends SpaceField {
-    constructor(wildText) {
-        super();
-        this.wildText = wildText;
-    }
-    type() {
-        throw new Error("should never ask a wild field for its type");
-    }
-    getQueryFieldDef(_fs) {
-        return this.wildText;
-    }
-}
-exports.WildSpaceField = WildSpaceField;
-class StructSpaceField extends SpaceField {
-    constructor(sourceDef) {
-        super();
-        this.sourceDef = sourceDef;
-    }
-    get fieldSpace() {
-        if (!this.space) {
-            this.space = new field_space_1.StaticSpace(this.sourceDef);
-        }
-        return this.space;
-    }
-    fieldDef() {
-        return this.sourceDef;
-    }
-    type() {
-        return { type: "struct" };
-    }
-}
-exports.StructSpaceField = StructSpaceField;
-class JoinSpaceField extends StructSpaceField {
-    constructor(intoFS, join) {
-        super(join.structDef());
-        this.intoFS = intoFS;
-        this.join = join;
-    }
-}
-exports.JoinSpaceField = JoinSpaceField;
-class ColumnSpaceField extends SpaceField {
-    constructor(def) {
-        super();
-        this.def = def;
-    }
-    fieldDef() {
-        return this.def;
-    }
-    type() {
-        return this.fieldTypeFromFieldDef(this.def);
-    }
-}
-exports.ColumnSpaceField = ColumnSpaceField;
-class QueryField extends SpaceField {
-    constructor(inSpace) {
-        super();
-        this.inSpace = inSpace;
-    }
-    type() {
-        return { type: "turtle" };
-    }
-}
-exports.QueryField = QueryField;
-class QueryFieldAST extends QueryField {
-    constructor(fs, turtle, name) {
-        super(fs);
-        this.turtle = turtle;
-        this.name = name;
-    }
-    getQueryFieldDef(fs) {
-        const def = this.turtle.getFieldDef(fs, this.nestParent);
-        if (this.renameAs) {
-            def.as = this.renameAs;
-        }
-        return def;
-    }
-    fieldDef() {
-        const def = this.turtle.getFieldDef(this.inSpace, this.nestParent);
-        if (this.renameAs) {
-            def.as = this.renameAs;
-        }
-        return def;
-    }
-}
-exports.QueryFieldAST = QueryFieldAST;
-class QueryFieldStruct extends QueryField {
-    constructor(fs, turtleDef) {
-        super(fs);
-        this.turtleDef = turtleDef;
-    }
-    rename(name) {
-        this.turtleDef = {
-            ...this.turtleDef,
-            as: name,
-        };
-    }
-    fieldDef() {
-        return this.turtleDef;
-    }
-    getQueryFieldDef(_fs) {
-        return this.fieldDef();
-    }
-}
-exports.QueryFieldStruct = QueryFieldStruct;
+const ast_main_1 = require("./ast/ast-main");
+// "Space Fields" are a field in a field space
 /**
  * FilteredAliasedName
  */
-class FANSPaceField extends SpaceField {
+class FANSPaceField extends ast_main_1.SpaceField {
     constructor(ref, inSpace, refInit) {
         super();
         this.ref = ref;
@@ -261,7 +78,7 @@ class FANSPaceField extends SpaceField {
         const fieldType = fieldTypeInfo.type;
         // TODO starting to feel like this should be a method call on a spaceentry
         if (model.isAtomicFieldType(fieldType)) {
-            if (fromField instanceof SpaceParam) {
+            if (fromField instanceof ast_main_1.SpaceParam) {
                 return {
                     type: fieldType,
                     name: this.as,
@@ -307,50 +124,4 @@ class FANSPaceField extends SpaceField {
     }
 }
 exports.FANSPaceField = FANSPaceField;
-class ReferenceField extends SpaceField {
-    constructor(fieldRef) {
-        super();
-        this.fieldRef = fieldRef;
-    }
-    getQueryFieldDef(fs) {
-        // Lookup string and generate error if it isn't defined.
-        const check = this.fieldRef.getField(fs);
-        if (check.error) {
-            this.fieldRef.log(check.error);
-        }
-        return this.fieldRef.refString;
-    }
-    type() {
-        return { type: "unknown" };
-    }
-}
-exports.ReferenceField = ReferenceField;
-class ExpressionFieldFromAst extends SpaceField {
-    constructor(space, exprDef) {
-        super();
-        this.space = space;
-        this.exprDef = exprDef;
-        this.fieldName = exprDef.defineName;
-    }
-    get name() {
-        return this.fieldName;
-    }
-    fieldDef() {
-        const def = this.exprDef.fieldDef(this.space, this.name);
-        this.defType = this.fieldTypeFromFieldDef(def);
-        return def;
-    }
-    getQueryFieldDef(fs) {
-        const def = this.exprDef.queryFieldDef(fs, this.name);
-        this.defType = this.fieldTypeFromFieldDef(def);
-        return def;
-    }
-    type() {
-        if (this.defType) {
-            return this.defType;
-        }
-        return this.fieldTypeFromFieldDef(this.fieldDef());
-    }
-}
-exports.ExpressionFieldFromAst = ExpressionFieldFromAst;
 //# sourceMappingURL=space-field.js.map

package/dist/lang/test/field-symbols.spec.js

@@ -22,9 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const space_field_1 = require("../space-field");
-const field_space_1 = require("../field-space");
-const ast_1 = require("../ast");
+const ast_main_1 = require("../ast/ast-main");
 /*
  **  A set of tests to make sure structdefs can become fieldspaces
  ** and the fieldspace produces the same strcutdef
@@ -41,7 +39,7 @@ describe("structdef comprehension", () => {
         };
     }
     function fieldRef(fieldPath) {
-        return fieldPath.split(".").map((name) => new ast_1.FieldName(name));
+        return fieldPath.split(".").map((name) => new ast_main_1.FieldName(name));
     }
     test(`import string field`, () => {
         const field = {
@@ -49,8 +47,8 @@ describe("structdef comprehension", () => {
             type: "string",
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(space_field_1.ColumnSpaceField);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(ast_main_1.ColumnSpaceField);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -61,8 +59,8 @@ describe("structdef comprehension", () => {
             numberType: "float",
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(space_field_1.ColumnSpaceField);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(ast_main_1.ColumnSpaceField);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -73,8 +71,8 @@ describe("structdef comprehension", () => {
             numberType: "integer",
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(space_field_1.ColumnSpaceField);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(ast_main_1.ColumnSpaceField);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -84,8 +82,8 @@ describe("structdef comprehension", () => {
             type: "boolean",
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(space_field_1.ColumnSpaceField);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(ast_main_1.ColumnSpaceField);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -99,8 +97,8 @@ describe("structdef comprehension", () => {
             fields: [{ type: "string", name: "b" }],
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t.b")).found).toBeInstanceOf(space_field_1.ColumnSpaceField);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t.b")).found).toBeInstanceOf(ast_main_1.ColumnSpaceField);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -114,8 +112,8 @@ describe("structdef comprehension", () => {
             fields: [{ type: "string", name: "a" }],
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t.a")).found).toBeInstanceOf(space_field_1.ColumnSpaceField);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t.a")).found).toBeInstanceOf(ast_main_1.ColumnSpaceField);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -136,8 +134,8 @@ describe("structdef comprehension", () => {
             fields: [{ type: "string", name: "a" }],
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t.a")).found).toBeInstanceOf(space_field_1.ColumnSpaceField);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t.a")).found).toBeInstanceOf(ast_main_1.ColumnSpaceField);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -153,8 +151,8 @@ describe("structdef comprehension", () => {
             ],
         };
         const struct = mkStructDef(field);
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(space_field_1.QueryFieldStruct);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(ast_main_1.QueryFieldStruct);
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
@@ -174,9 +172,9 @@ describe("structdef comprehension", () => {
                 constant: false,
             },
         };
-        const space = new field_space_1.StaticSpace(struct);
-        expect(space.lookup(fieldRef("cReqStr")).found).toBeInstanceOf(space_field_1.DefinedParameter);
-        expect(space.lookup(fieldRef("cOptStr")).found).toBeInstanceOf(space_field_1.DefinedParameter);
+        const space = new ast_main_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("cReqStr")).found).toBeInstanceOf(ast_main_1.DefinedParameter);
+        expect(space.lookup(fieldRef("cOptStr")).found).toBeInstanceOf(ast_main_1.DefinedParameter);
     });
 });
 //# sourceMappingURL=field-symbols.spec.js.map

package/dist/lang/test/parse.spec.js

@@ -25,8 +25,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const model_1 = require("../../model");
 const sql_block_1 = require("../../model/sql_block");
-const ast_1 = require("../ast");
-const field_space_1 = require("../field-space");
+const ast_main_1 = require("../ast/ast-main");
 const test_translator_1 = require("./test-translator");
 const lodash_1 = require("lodash");
 const util_1 = require("util");
@@ -298,10 +297,10 @@ class BetaExpression extends Testable {
     }
     compile() {
         const exprAst = this.ast();
-        if (exprAst instanceof ast_1.ExpressionDef) {
+        if (exprAst instanceof ast_main_1.ExpressionDef) {
             const aStruct = this.internalModel.contents.ab;
             if (aStruct.type === "struct") {
-                const tstFS = new field_space_1.StaticSpace(aStruct);
+                const tstFS = new ast_main_1.StaticSpace(aStruct);
                 const exprDef = exprAst.getExpression(tstFS);
                 if (inspectCompile) {
                     console.log("EXPRESSION: ", (0, test_translator_1.pretty)(exprDef));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.22-dev230119001546",
+  "version": "0.0.22-dev230119193053",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/lang/field-space.d.ts

@@ -1,159 +0,0 @@
-import { Dialect } from "../dialect";
-import * as model from "../model/malloy_types";
-import { ExploreField, FieldListEdit, FieldDeclaration, WildcardFieldReference, Join, FieldName, HasParameter, FieldCollectionMember, QueryItem, MalloyElement, FieldReference } from "./ast";
-import { SpaceField, SpaceEntry } from "./space-field";
-interface LookupFound {
-    found: SpaceEntry;
-    error: undefined;
-}
-interface LookupError {
-    error: string;
-    found: undefined;
-}
-export declare type LookupResult = LookupFound | LookupError;
-/**
- * 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;
-}
-/**
- * The father of all FieldSpaces is a wrapper for a StructDef.
- */
-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;
-}
-export declare type SourceSpec = model.StructDef | FieldSpace;
-/**
- * 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.
- */
-declare class SpaceSeed {
-    readonly sourceSpec: SourceSpec;
-    private spaceSpec;
-    private asFS?;
-    private asStruct?;
-    constructor(sourceSpec: SourceSpec);
-    get structDef(): model.StructDef;
-    get fieldSpace(): FieldSpace;
-}
-/**
- * A FieldSpace which may undergo modification
- */
-export declare class DynamicSpace extends StaticSpace {
-    protected final: model.StructDef | undefined;
-    protected source: SpaceSeed;
-    outputFS?: QuerySpace;
-    completions: (() => void)[];
-    private complete;
-    constructor(extending: SourceSpec);
-    /**
-     * Factory for DynamicSpace when there are accept/except edits
-     * @param from A structdef which seeds this space
-     * @param choose A accept/except edit of the "from" fields
-     */
-    static filteredFrom(from: model.StructDef, choose?: FieldListEdit): DynamicSpace;
-    whenComplete(finalizeStep: () => void): void;
-    isComplete(): void;
-    protected setEntry(name: string, value: SpaceEntry): void;
-    addParameters(params: HasParameter[]): DynamicSpace;
-    newEntry(name: string, astEl: MalloyElement, entry: SpaceEntry): void;
-    addField(...defs: ExploreField[]): void;
-    addFieldDef(fd: model.FieldDef): void;
-    structDef(): model.StructDef;
-}
-/**
- * Unlike a source, which is a refinement of a namespace, a query
- * is creating a new unrelated namespace. The query starts with a
- * source, which it might modify. This set of fields used to resolve
- * expressions in the query is called the "input space". There is a
- * specialized QuerySpace for each type of query operation.
- *
- * The query output is managed by an instance of ResultSpace.
- */
-export declare class QuerySpace extends DynamicSpace {
-    readonly result: ResultSpace;
-    nestParent?: QuerySpace;
-    extendList: string[];
-    constructor(input: SourceSpec, result: ResultSpace);
-    extendSource(extendField: Join | FieldDeclaration): void;
-}
-export declare abstract class ResultSpace extends DynamicSpace {
-    readonly queryInputSpace: FieldSpace;
-    readonly exprSpace: QuerySpace;
-    astEl?: MalloyElement | undefined;
-    abstract readonly segmentType: "reduce" | "project" | "index";
-    constructor(queryInputSpace: FieldSpace);
-    log(s: string): void;
-    addMembers(members: FieldCollectionMember[]): void;
-    addReference(ref: FieldReference): void;
-    addWild(wild: WildcardFieldReference): void;
-    /**
-     * Check for the definition of an ungrouping reference in the result space,
-     * or in the case of an exclude reference, if this query is nested
-     * in another query, in the result space of a query that this query
-     * is nested inside of.
-     */
-    checkUngroup(fn: FieldName, isExclude: boolean): void;
-    addQueryItems(...qiList: QueryItem[]): void;
-    canContain(_qd: model.QueryFieldDef): boolean;
-    protected queryFieldDefs(): model.QueryFieldDef[];
-    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 class IndexFieldSpace extends ResultSpace {
-    readonly segmentType = "index";
-    fieldList: Set<string>;
-    addReference(ref: FieldReference): void;
-    addWild(wild: WildcardFieldReference): void;
-    getPipeSegment(refineIndex?: model.PipeSegment): model.IndexSegment;
-}
-/**
- * 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 {};