@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207171614

package/dist/lang/ast/types/granular-result.d.ts

@@ -0,0 +1,7 @@
+import { TimestampUnit } from "../../../model/malloy_types";
+import { ExprValue } from "./expr-value";
+import { TimeResult } from "./time-result";
+export interface GranularResult extends TimeResult {
+    timeframe: TimestampUnit;
+}
+export declare function isGranularResult(v: ExprValue): v is GranularResult;

package/dist/lang/ast/types/granular-result.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGranularResult = void 0;
+function isGranularResult(v) {
+    if (v.dataType !== "date" && v.dataType !== "timestamp") {
+        return false;
+    }
+    return v.timeframe !== undefined;
+}
+exports.isGranularResult = isGranularResult;
+//# sourceMappingURL=granular-result.js.map

package/dist/lang/ast/types/lookup-result.d.ts

@@ -0,0 +1,10 @@
+import { SpaceEntry } from "./space-entry";
+export interface LookupFound {
+    found: SpaceEntry;
+    error: undefined;
+}
+export interface LookupError {
+    error: string;
+    found: undefined;
+}
+export declare type LookupResult = LookupFound | LookupError;

package/dist/lang/ast/types/lookup-result.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=lookup-result.js.map

package/dist/lang/ast/types/malloy-element.d.ts

@@ -0,0 +1,106 @@
+import { MalloyTranslation } from "../../parse-malloy";
+import { ModelDataRequest } from "../../translate-response";
+import { DocumentCompileResult } from "./document-compile-result";
+import { NameSpace } from "./name-space";
+import { ModelEntry } from "./model-entry";
+import { DocumentLocation, DocumentReference, ModelDef, Query, SQLBlockStructDef } from "../../../model/malloy_types";
+export declare abstract class MalloyElement {
+    abstract elementType: string;
+    codeLocation?: 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(): DocumentLocation;
+    set location(loc: DocumentLocation | undefined);
+    protected namespace(): NameSpace | undefined;
+    modelEntry(reference: string | ModelEntryReference): ModelEntry | undefined;
+    private xlate?;
+    translator(): MalloyTranslation | undefined;
+    setTranslator(x: MalloyTranslation): void;
+    addReference(reference: 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 Unimplemented extends MalloyElement {
+    elementType: string;
+    reported: boolean;
+}
+declare type ChildBody = MalloyElement | MalloyElement[];
+declare type ElementChildren = Record<string, ChildBody>;
+export declare class ModelEntryReference extends MalloyElement {
+    readonly name: string;
+    elementType: string;
+    constructor(name: string);
+    get refString(): string;
+    toString(): string;
+}
+export interface DocStatement extends MalloyElement {
+    execute(doc: Document): ModelDataRequest;
+}
+export declare function isDocStatement(e: MalloyElement): e is DocStatement;
+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 RunList extends ListOf<DocStatement> {
+    execCursor: number;
+    executeList(doc: Document): 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: Query[];
+    sqlBlocks: SQLBlockStructDef[];
+    statements: RunList;
+    didInitModel: boolean;
+    constructor(statements: DocStatement[]);
+    initModelDef(extendingModelDef: ModelDef | undefined): void;
+    compile(): DocumentCompileResult;
+    modelDef(): ModelDef;
+    defineSQL(sql: SQLBlockStructDef, name?: string): boolean;
+    getEntry(str: string): ModelEntry;
+    setEntry(str: string, ent: ModelEntry): void;
+}
+export {};

package/dist/lang/ast/types/malloy-element.js

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Document = exports.RunList = exports.ListOf = exports.isDocStatement = exports.ModelEntryReference = exports.Unimplemented = exports.MalloyElement = void 0;
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const lodash_1 = require("lodash");
+const malloy_types_1 = require("../../../model/malloy_types");
+class MalloyElement {
+    /**
+     * @param kids All children passed to the constructor are not optional
+     */
+    constructor(kids) {
+        this.children = {};
+        this.parent = null;
+        this.logged = new Set();
+        if (kids) {
+            this.has(kids);
+        }
+    }
+    /**
+     * 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) {
+        for (const kidName in kids) {
+            const kidValue = kids[kidName];
+            if (kidValue !== undefined) {
+                this.children[kidName] = kidValue;
+                if (kidValue instanceof MalloyElement) {
+                    kidValue.parent = this;
+                }
+                else {
+                    for (const oneKid of kidValue) {
+                        oneKid.parent = this;
+                    }
+                }
+            }
+        }
+    }
+    get location() {
+        if (this.codeLocation) {
+            return this.codeLocation;
+        }
+        if (this.parent) {
+            return this.parent.location;
+        }
+        return {
+            url: this.sourceURL,
+            range: {
+                start: { line: 0, character: 0 },
+                end: { line: 0, character: 0 },
+            },
+        };
+    }
+    set location(loc) {
+        this.codeLocation = loc;
+    }
+    namespace() {
+        if (this instanceof Document) {
+            return this;
+        }
+        else if (this.parent) {
+            return this.parent.namespace();
+        }
+        throw new Error("INTERNAL ERROR: Translation without document scope");
+    }
+    modelEntry(reference) {
+        var _a;
+        const key = reference instanceof ModelEntryReference ? reference.name : reference;
+        const result = (_a = this.namespace()) === null || _a === void 0 ? void 0 : _a.getEntry(key);
+        if (reference instanceof ModelEntryReference) {
+            if ((result === null || result === void 0 ? void 0 : result.entry.type) === "query") {
+                this.addReference({
+                    type: "queryReference",
+                    text: key,
+                    definition: result.entry,
+                    location: reference.location,
+                });
+            }
+            else if ((result === null || result === void 0 ? void 0 : result.entry.type) === "struct") {
+                if ((0, malloy_types_1.isSQLBlock)(result.entry)) {
+                    this.addReference({
+                        type: "sqlBlockReference",
+                        text: key,
+                        definition: result.entry,
+                        location: reference.location,
+                    });
+                }
+                else {
+                    this.addReference({
+                        type: "exploreReference",
+                        text: key,
+                        definition: result.entry,
+                        location: reference.location,
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    translator() {
+        if (this.xlate) {
+            return this.xlate;
+        }
+        if (this.parent) {
+            return this.parent.translator();
+        }
+        return undefined;
+    }
+    setTranslator(x) {
+        this.xlate = x;
+    }
+    addReference(reference) {
+        var _a;
+        (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.addReference(reference);
+    }
+    get sourceURL() {
+        const trans = this.translator();
+        return (trans === null || trans === void 0 ? void 0 : trans.sourceURL) || "(missing)";
+    }
+    errorsExist() {
+        var _a;
+        const logger = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.logger;
+        if (logger) {
+            return logger.hasErrors();
+        }
+        return true;
+    }
+    log(message) {
+        if (this.codeLocation) {
+            /*
+             * If this element has a location, then don't report the same
+             * error message at the same location more than once
+             */
+            if (this.logged.has(message)) {
+                return;
+            }
+            this.logged.add(message);
+        }
+        const trans = this.translator();
+        const msg = { at: this.location, message };
+        const logTo = trans === null || trans === void 0 ? void 0 : trans.root.logger;
+        if (logTo) {
+            logTo.log(msg);
+            return;
+        }
+        throw new Error(`Translation error (without error reporter):\n${JSON.stringify(msg, null, 2)}`);
+    }
+    /**
+     * 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() {
+        return this.stringify("", 0);
+    }
+    stringify(prefix, indent) {
+        const left = " ".repeat(indent);
+        let asString = `${left}${prefix}<${this.elementType}>${this.varInfo()}`;
+        for (const kidLabel of Object.keys(this.children)) {
+            const kiddle = this.children[kidLabel];
+            if (kiddle instanceof MalloyElement) {
+                asString += "\n" + kiddle.stringify(`${kidLabel}: `, indent + 2);
+            }
+            else {
+                asString += `\n${left}  ${kidLabel}: [`;
+                if (kiddle.length > 0) {
+                    asString +=
+                        "\n" +
+                            kiddle.map((k) => k.stringify("", indent + 4)).join("\n") +
+                            `\n${left}  `;
+                }
+                asString += "]";
+            }
+        }
+        return asString;
+    }
+    walk(callBack) {
+        callBack(this);
+        for (const kidLabel of Object.keys(this.children)) {
+            const kiddle = this.children[kidLabel];
+            if (kiddle instanceof MalloyElement) {
+                kiddle.walk(callBack);
+            }
+            else {
+                for (const k of kiddle) {
+                    k.walk(callBack);
+                }
+            }
+        }
+    }
+    varInfo() {
+        let extra = "";
+        for (const [key, value] of Object.entries(this)) {
+            if (key !== "elementType") {
+                if (typeof value == "boolean") {
+                    extra += value ? ` ${key}` : ` !${key}`;
+                }
+                else if (typeof value === "string" || typeof value === "number") {
+                    extra += ` ${key}=${value}`;
+                }
+            }
+        }
+        return extra;
+    }
+    internalError(msg) {
+        this.log(`INTERNAL ERROR IN TRANSLATION: ${msg}`);
+        return new Error(msg);
+    }
+}
+exports.MalloyElement = MalloyElement;
+class Unimplemented extends MalloyElement {
+    constructor() {
+        super(...arguments);
+        this.elementType = "unimplemented";
+        this.reported = false;
+    }
+}
+exports.Unimplemented = Unimplemented;
+class ModelEntryReference extends MalloyElement {
+    constructor(name) {
+        super();
+        this.name = name;
+        this.elementType = "modelEntryReference";
+    }
+    get refString() {
+        return this.name;
+    }
+    toString() {
+        return this.refString;
+    }
+}
+exports.ModelEntryReference = ModelEntryReference;
+function isDocStatement(e) {
+    return e.execute !== undefined;
+}
+exports.isDocStatement = isDocStatement;
+class ListOf extends MalloyElement {
+    constructor(listDesc, elements) {
+        super();
+        this.elementType = "genericElementList";
+        this.elements = elements;
+        if (this.elementType === "genericElementList") {
+            this.elementType = listDesc;
+        }
+        this.newContents();
+    }
+    newContents() {
+        this.has({ [this.elementType]: this.elements });
+    }
+    get list() {
+        return this.elements;
+    }
+    empty() {
+        return this.elements.length === 0;
+    }
+    notEmpty() {
+        return this.elements.length > 0;
+    }
+    push(...el) {
+        this.elements.push(...el);
+        this.newContents();
+        return this.elements;
+    }
+}
+exports.ListOf = ListOf;
+class RunList extends ListOf {
+    constructor() {
+        super(...arguments);
+        this.execCursor = 0;
+    }
+    executeList(doc) {
+        while (this.execCursor < this.elements.length) {
+            if (doc.errorsExist()) {
+                // This stops cascading errors
+                return;
+            }
+            const el = this.elements[this.execCursor];
+            if (isDocStatement(el)) {
+                const resp = el.execute(doc);
+                if (resp) {
+                    return resp;
+                }
+                this.execCursor += 1;
+            }
+        }
+        return undefined;
+    }
+}
+exports.RunList = RunList;
+/**
+ * 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
+ */
+class Document extends MalloyElement {
+    constructor(statements) {
+        super();
+        this.elementType = "document";
+        this.documentModel = {};
+        this.queryList = [];
+        this.sqlBlocks = [];
+        this.didInitModel = false;
+        this.statements = new RunList("topLevelStatements", statements);
+        this.has({ statements });
+    }
+    initModelDef(extendingModelDef) {
+        if (this.didInitModel) {
+            return;
+        }
+        this.documentModel = {};
+        this.queryList = [];
+        this.sqlBlocks = [];
+        if (extendingModelDef) {
+            for (const inName in extendingModelDef.contents) {
+                const struct = extendingModelDef.contents[inName];
+                if (struct.type == "struct") {
+                    const exported = extendingModelDef.exports.includes(inName);
+                    this.setEntry(inName, { entry: struct, exported });
+                }
+            }
+        }
+        this.didInitModel = true;
+    }
+    compile() {
+        const needs = this.statements.executeList(this);
+        const ret = {
+            modelDef: this.modelDef(),
+            queryList: this.queryList,
+            sqlBlocks: this.sqlBlocks,
+            needs,
+        };
+        return ret;
+    }
+    modelDef() {
+        const def = { name: "", exports: [], contents: {} };
+        for (const entry in this.documentModel) {
+            const entryDef = this.documentModel[entry].entry;
+            if (entryDef.type === "struct" || entryDef.type === "query") {
+                if (this.documentModel[entry].exported) {
+                    def.exports.push(entry);
+                }
+                def.contents[entry] = (0, lodash_1.cloneDeep)(entryDef);
+            }
+        }
+        return def;
+    }
+    defineSQL(sql, name) {
+        const ret = { ...sql, as: `$${this.sqlBlocks.length}` };
+        if (name) {
+            if (this.getEntry(name)) {
+                return false;
+            }
+            ret.as = name;
+            this.setEntry(name, { entry: ret, sqlType: true });
+        }
+        this.sqlBlocks.push(ret);
+        return true;
+    }
+    getEntry(str) {
+        return this.documentModel[str];
+    }
+    setEntry(str, ent) {
+        this.documentModel[str] = ent;
+    }
+}
+exports.Document = Document;
+//# sourceMappingURL=malloy-element.js.map

package/dist/lang/ast/types/model-entry.d.ts

@@ -0,0 +1,6 @@
+import { NamedModelObject } from "../../../model/malloy_types";
+export interface ModelEntry {
+    entry: NamedModelObject;
+    exported?: boolean;
+    sqlType?: boolean;
+}

package/dist/lang/ast/types/model-entry.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model-entry.js.map

package/dist/lang/ast/types/name-space.d.ts

@@ -0,0 +1,5 @@
+import { ModelEntry } from "./model-entry";
+export interface NameSpace {
+    getEntry(name: string): ModelEntry | undefined;
+    setEntry(name: string, value: ModelEntry, exported: boolean): void;
+}

package/dist/lang/ast/types/name-space.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=name-space.js.map

package/dist/lang/ast/types/nested-query.d.ts

@@ -0,0 +1,3 @@
+import { NestDefinition, NestRefinement } from "../query-properties/nest";
+import { NestReference } from "../query-properties/nest-reference";
+export declare type NestedQuery = NestReference | NestDefinition | NestRefinement;

package/dist/lang/ast/types/nested-query.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=nested-query.js.map

package/dist/lang/ast/types/op-desc.d.ts

@@ -0,0 +1,6 @@
+import { PipeSegment } from "../../../model/malloy_types";
+import { FieldSpace } from "./field-space";
+export interface OpDesc {
+    segment: PipeSegment;
+    outputSpace: () => FieldSpace;
+}