@malloydata/malloy 0.0.1 → 0.0.2

package/dist/dialect/dialect.d.ts

@@ -1,5 +1,5 @@
 import { AtomicFieldTypeInner, TimeFieldType, TimestampUnit, ExtractUnit, DialectFragment, TimeValue } from "..";
-import { Expr, Sampling, StructDef, TypecastFragment } from "../model";
+import { Expr, Sampling, StructDef, TypecastFragment } from "../model/malloy_types";
 interface DialectField {
     type: string;
     sqlExpression: string;

package/dist/dialect/dialect.js

@@ -13,6 +13,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dialect = void 0;
+// Can't get these from "../model" because model includes this file
+// and that can create a circular reference problem. This is a patch
+// and really indicates a problem in the relationship between
+// dialect and model, it's going to come up again some time.
+const malloy_types_1 = require("../model/malloy_types");
 class Dialect {
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error("Dialect has no final Stage but called Anyway");
@@ -45,6 +50,14 @@ class Dialect {
                 return this.sqlCast(df);
             case "regexpMatch":
                 return this.sqlRegexpMatch(df.expr, df.regexp);
+            case "div": {
+                if (this.divisionIsInteger) {
+                    return (0, malloy_types_1.mkExpr) `${df.numerator}*1.0/${df.denominator}`;
+                }
+                return (0, malloy_types_1.mkExpr) `${df.numerator}/${df.denominator}`;
+            }
+            case "timeLiteral":
+                return [this.sqlLiteralTime(df.literal, df.literalType, df.timezone)];
         }
     }
     sqlSumDistinct(_key, _value) {

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

@@ -1,5 +1,5 @@
 import { Expr } from "../../model/malloy_types";
-import { FSPair } from "../field-space";
+import { FieldSpace } from "../field-space";
 import { ExprValue, ExpressionDef, Equality } from "./index";
 /**
  * All of the magic of malloy expressions eventually flows to here,
@@ -12,5 +12,5 @@ import { ExprValue, ExpressionDef, Equality } from "./index";
  * @param right Right Value
  * @returns ExprValue of the expression
  */
-export declare function applyBinary(fs: FSPair, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
+export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
 export declare function nullsafeNot(expr: Expr, op?: Equality): Expr;

package/dist/lang/ast/apply-expr.js

@@ -40,12 +40,28 @@ function applyBinary(fs, left, op, right) {
         return numeric(fs, left, op, right);
     }
     if (oneOf(op, "/")) {
-        if (fs.in.getDialect().divisionIsInteger) {
-            return numeric(fs, left, "*1.0/", right);
+        const num = left.getExpression(fs);
+        const denom = right.getExpression(fs);
+        if (num.dataType != "number") {
+            left.log("Numerator for division mus tbe a number");
+        }
+        else if (denom.dataType != "number") {
+            right.log("Denominator for division mus tbe a number");
         }
         else {
-            return numeric(fs, left, op, right);
+            const div = {
+                type: "dialect",
+                function: "div",
+                numerator: num.value,
+                denominator: denom.value,
+            };
+            return {
+                dataType: "number",
+                aggregate: num.aggregate || denom.aggregate,
+                value: [div],
+            };
         }
+        return (0, index_1.errorFor)("divide type mismatch");
     }
     left.log(`Canot use ${op} operator here`);
     return (0, index_1.errorFor)("applybinary bad operator");

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

@@ -1,5 +1,5 @@
 import { By, AtomicFieldType, FieldTypeDef, Fragment, TimeFieldType } from "../../model/malloy_types";
-import { FSPair, FieldSpace } from "../field-space";
+import { FieldSpace } from "../field-space";
 import { Filter, MalloyElement, ExprValue, FieldValueType, FragType } from "./index";
 import { FieldName, FieldReference } from "./ast-main";
 /**
@@ -17,7 +17,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * the translation code a chance to convert to match your expectations
      * @param space Namespace for looking up field references
      */
-    abstract getExpression(fs: FSPair): ExprValue;
+    abstract getExpression(fs: FieldSpace): ExprValue;
     legalChildTypes: FragType[];
     /**
      * Some operators want to give the right hand value a chance to
@@ -26,7 +26,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param fs FieldSpace
      * @returns Translated expression or undefined
      */
-    requestExpression(fs: FSPair): ExprValue | undefined;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
     defaultFieldName(): string | undefined;
     /**
      * Check an expression for type compatibility
@@ -44,19 +44,19 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param expr The "other" (besdies 'this') value
      * @returns The translated expression
      */
-    apply(fs: FSPair, op: string, left: ExpressionDef): ExprValue;
+    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: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
     private get constantFs();
     constantValue(): ExprValue;
     constantCondition(type: AtomicFieldType): ExprValue;
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(fs: FSPair): ExprValue | undefined;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
 }
 export declare class FieldDeclaration extends MalloyElement {
     readonly expr: ExpressionDef;
@@ -66,7 +66,7 @@ export declare class FieldDeclaration extends MalloyElement {
     isMeasure?: boolean;
     constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
     fieldDef(fs: FieldSpace, exprName: string): FieldTypeDef;
-    queryFieldDef(exprFS: FSPair, exprName: string): FieldTypeDef;
+    queryFieldDef(exprFS: FieldSpace, exprName: string): FieldTypeDef;
 }
 export declare class TypeMistmatch extends Error {
 }
@@ -74,13 +74,13 @@ export declare class ExprString extends ExpressionDef {
     readonly value: string;
     elementType: string;
     constructor(value: string);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprNumber extends ExpressionDef {
     readonly n: string;
     elementType: string;
     constructor(n: string);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
     constantExpression(): ExprValue;
 }
 export declare class ExprRegEx extends ExpressionDef {
@@ -93,7 +93,7 @@ export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
     constructor(timeType: TimeFieldType, value: Fragment[] | string, aggregate?: boolean);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
     static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
 }
 declare abstract class Unary extends ExpressionDef {
@@ -104,7 +104,7 @@ export declare class ExprNot extends Unary {
     elementType: string;
     legalChildTypes: FragType[];
     constructor(expr: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class Boolean extends ExpressionDef {
     readonly value: "true" | "false";
@@ -119,7 +119,7 @@ export declare abstract class BinaryBoolean<opType extends string> extends Expre
     elementType: string;
     legalChildTypes: FragType[];
     constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
     elementType: string;
@@ -130,8 +130,8 @@ export declare class ExprIdReference extends ExpressionDef {
     elementType: string;
     constructor(fieldReference: FieldReference);
     get refString(): string;
-    getExpression(fs: FSPair): ExprValue;
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
 }
 export declare class ExprNULL extends ExpressionDef {
     elementType: string;
@@ -141,15 +141,15 @@ export declare class ExprParens extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     constructor(expr: ExpressionDef);
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(fs: FSPair): ExprValue | undefined;
-    getExpression(fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprMinus extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     constructor(expr: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare abstract class BinaryNumeric<opType extends string> extends ExpressionDef {
     readonly left: ExpressionDef;
@@ -157,7 +157,7 @@ export declare abstract class BinaryNumeric<opType extends string> extends Expre
     readonly right: ExpressionDef;
     elementType: string;
     constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprAddSub extends BinaryNumeric<"+" | "-"> {
     elementType: string;
@@ -168,9 +168,9 @@ export declare class ExprMulDiv extends BinaryNumeric<"*" | "/"> {
 export declare class ExprAlternationTree extends BinaryBoolean<"|" | "&"> {
     elementType: string;
     constructor(left: ExpressionDef, op: "|" | "&", right: ExpressionDef);
-    apply(fs: FSPair, applyOp: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FSPair): ExprValue | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, applyOp: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 declare abstract class ExprAggregateFunction extends ExpressionDef {
     readonly func: string;
@@ -180,7 +180,7 @@ declare abstract class ExprAggregateFunction extends ExpressionDef {
     legalChildTypes: FragType[];
     constructor(func: string, expr?: ExpressionDef);
     returns(_forExpression: ExprValue): FieldValueType;
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprMin extends ExprAggregateFunction {
     legalChildTypes: FragType[];
@@ -208,7 +208,7 @@ export declare class ExprCount extends ExprAggregateFunction {
     elementType: string;
     constructor(source?: FieldReference | undefined);
     defaultFieldName(): string | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprAvg extends ExprAsymmetric {
     constructor(expr: ExpressionDef | undefined, source?: FieldReference);
@@ -224,21 +224,21 @@ export declare class ExprUngroup extends ExpressionDef {
     elementType: string;
     constructor(control: "all" | "exclude", expr: ExpressionDef, fields: FieldName[]);
     returns(_forExpression: ExprValue): FieldValueType;
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class WhenClause extends ExpressionDef {
     readonly whenThis: ExpressionDef;
     readonly thenThis: ExpressionDef;
     elementType: string;
     constructor(whenThis: ExpressionDef, thenThis: ExpressionDef);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprCase extends ExpressionDef {
     readonly when: WhenClause[];
     readonly elseClause?: ExpressionDef | undefined;
     elementType: string;
     constructor(when: WhenClause[], elseClause?: ExpressionDef | undefined);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprFilter extends ExpressionDef {
     readonly expr: ExpressionDef;
@@ -246,7 +246,7 @@ export declare class ExprFilter extends ExpressionDef {
     elementType: string;
     legalChildTypes: FragType[];
     constructor(expr: ExpressionDef, filter: Filter);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 declare type CastType = "string" | "number" | "boolean" | "date" | "timestamp";
 export declare function isCastType(t: string): t is CastType;
@@ -256,22 +256,22 @@ export declare class ExprCast extends ExpressionDef {
     readonly safe: boolean;
     elementType: string;
     constructor(expr: ExpressionDef, castType: CastType, safe?: boolean);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class TopBy extends MalloyElement {
     readonly by: string | ExpressionDef;
     elementType: string;
     constructor(by: string | ExpressionDef);
-    getBy(fs: FSPair): By;
+    getBy(fs: FieldSpace): By;
 }
 export declare class Range extends ExpressionDef {
     readonly first: ExpressionDef;
     readonly last: ExpressionDef;
     elementType: string;
     constructor(first: ExpressionDef, last: ExpressionDef);
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FSPair): ExprValue | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class PickWhen extends MalloyElement {
     readonly pick: ExpressionDef | undefined;
@@ -284,8 +284,8 @@ export declare class Pick extends ExpressionDef {
     readonly elsePick?: ExpressionDef | undefined;
     elementType: string;
     constructor(choices: PickWhen[], elsePick?: ExpressionDef | undefined);
-    requestExpression(fs: FSPair): ExprValue | undefined;
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    getExpression(fs: FSPair): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export {};

package/dist/lang/ast/ast-expr.js

@@ -117,11 +117,8 @@ class ConstantFieldSpace {
             found: undefined,
         };
     }
-    getDialect() {
-        // well dialects totally make this wrong and broken and stupid and useless
-        // but since this is only used for parameters which are also wrong and
-        // broken and stupid and useless, this will do for now
-        throw new Error("I just put this line of code here to make things compile");
+    dialectObj() {
+        return undefined;
     }
     whenComplete(step) {
         step();
@@ -140,10 +137,7 @@ class ConstantSubExpression extends ExpressionDef {
         if (!this.cfs) {
             this.cfs = new ConstantFieldSpace();
         }
-        return {
-            in: this.cfs,
-            out: this.cfs,
-        };
+        return this.cfs;
     }
     constantValue() {
         return this.expr.getExpression(this.constantFs);
@@ -179,11 +173,7 @@ class FieldDeclaration extends index_1.MalloyElement {
          * a refactor of QueryFieldSpace might someday be the place where this should
          * happen.
          */
-        const defPair = {
-            in: new field_space_1.DefSpace(fs, this),
-            out: fs,
-        };
-        return this.queryFieldDef(defPair, exprName);
+        return this.queryFieldDef(new field_space_1.DefSpace(fs, this), exprName);
     }
     queryFieldDef(exprFS, exprName) {
         let exprValue;
@@ -391,7 +381,7 @@ class ExprIdReference extends ExpressionDef {
         return this.fieldReference.refString;
     }
     getExpression(fs) {
-        const def = this.fieldReference.getField(fs.in);
+        const def = this.fieldReference.getField(fs);
         if (def.found) {
             // TODO if type is a query or a struct this should fail nicely
             const typeMixin = def.found.type();
@@ -404,7 +394,7 @@ class ExprIdReference extends ExpressionDef {
         return (0, index_1.errorFor)(def.error);
     }
     apply(fs, op, expr) {
-        const entry = this.fieldReference.getField(fs.in).found;
+        const entry = this.fieldReference.getField(fs).found;
         if (entry instanceof space_field_1.SpaceParam) {
             const cParam = entry.parameter();
             if ((0, malloy_types_1.isConditionParameter)(cParam)) {
@@ -548,7 +538,7 @@ class ExprAggregateFunction extends ExpressionDef {
         let exprVal = (_a = this.expr) === null || _a === void 0 ? void 0 : _a.getExpression(fs);
         let structPath = (_b = this.source) === null || _b === void 0 ? void 0 : _b.refString;
         if (this.source) {
-            const sourceFoot = this.source.getField(fs.in).found;
+            const sourceFoot = this.source.getField(fs).found;
             if (sourceFoot) {
                 const footType = sourceFoot.type();
                 if ((0, malloy_types_1.isAtomicFieldType)(footType.type)) {
@@ -705,19 +695,24 @@ class ExprUngroup extends ExpressionDef {
         }
         const ungroup = { type: this.control, e: exprVal.value };
         if (this.typeCheck(this.expr, { ...exprVal, aggregate: false })) {
-            const dstFields = [];
-            for (const mustBeInOutput of this.fields) {
-                const name = mustBeInOutput.refString;
+            if (this.fields.length > 0) {
+                let qs = fs;
+                if (fs instanceof field_space_1.DefSpace) {
+                    qs = fs.realFS;
+                }
+                if (!(qs instanceof field_space_1.QuerySpace)) {
+                    this.log(`${this.control}() must be in a query -- weird internal error`);
+                    return (0, index_1.errorFor)("ungroup query check");
+                }
+                const output = qs.result;
+                const dstFields = [];
                 const isExclude = this.control == "exclude";
-                const resultSpace = fs.out;
-                if (resultSpace instanceof field_space_1.QuerySpace) {
-                    resultSpace.whenComplete(() => {
-                        resultSpace.checkUngroup(mustBeInOutput, isExclude);
+                for (const mustBeInOutput of this.fields) {
+                    output.whenComplete(() => {
+                        output.checkUngroup(mustBeInOutput, isExclude);
                     });
-                    dstFields.push(name);
+                    dstFields.push(mustBeInOutput.refString);
                 }
-            }
-            if (dstFields.length > 0) {
                 ungroup.fields = dstFields;
             }
             return {

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

@@ -1,5 +1,5 @@
 import * as model from "../../model/malloy_types";
-import { FieldSpace, FSPair, QuerySpace, LookupResult } from "../field-space";
+import { FieldSpace, QuerySpace, LookupResult } from "../field-space";
 import { MalloyTranslation } from "../parse-malloy";
 import { ConstantSubExpression, ExpressionDef, FieldDeclaration } from "./index";
 import { SQLBlockRequest } from "../../model/sql_block";
@@ -149,7 +149,7 @@ export declare class QuerySource extends Mallobj {
 export declare abstract class Join extends MalloyElement {
     abstract name: ModelEntryReference;
     abstract structDef(): model.StructDef;
-    abstract fixupJoinOn(outer: FSPair, inStruct: model.StructDef): void;
+    abstract fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): void;
 }
 export declare class KeyJoin extends Join {
     readonly name: ModelEntryReference;
@@ -158,7 +158,7 @@ export declare class KeyJoin extends Join {
     elementType: string;
     constructor(name: ModelEntryReference, source: Mallobj, keyExpr: ExpressionDef);
     structDef(): model.StructDef;
-    fixupJoinOn(outer: FSPair, inStruct: model.StructDef): void;
+    fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): void;
 }
 declare type ExpressionJoinType = "many" | "one" | "cross";
 export declare class ExpressionJoin extends Join {
@@ -170,7 +170,7 @@ export declare class ExpressionJoin extends Join {
     constructor(name: ModelEntryReference, source: Mallobj);
     set joinOn(joinExpr: ExpressionDef | undefined);
     get joinOn(): ExpressionDef | undefined;
-    fixupJoinOn(outer: FSPair, inStruct: model.StructDef): model.Expr | undefined;
+    fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): model.Expr | undefined;
     structDef(): model.StructDef;
 }
 export declare class Joins extends ListOf<Join> {
@@ -188,14 +188,14 @@ export declare class FilterElement extends MalloyElement {
     readonly exprSrc: string;
     elementType: string;
     constructor(expr: ExpressionDef, exprSrc: string);
-    filterExpression(fs: FSPair): model.FilterExpression;
+    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: FSPair): model.FilterExpression[];
+    getFilterList(fs: FieldSpace): model.FilterExpression[];
 }
 export declare class DeclareFields extends ListOf<FieldDeclaration> {
     constructor(fields: FieldDeclaration[], fieldType?: string);
@@ -215,7 +215,7 @@ export declare class FieldName extends MalloyElement {
     constructor(name: string);
     get refString(): string;
     toString(): string;
-    getField(fs: FSPair): LookupResult;
+    getField(fs: FieldSpace): LookupResult;
 }
 export declare class FieldReference extends ListOf<FieldName> {
     elementType: string;
@@ -307,11 +307,11 @@ export declare class OrderBy extends MalloyElement {
     elementType: string;
     constructor(field: number | FieldName, dir?: "asc" | "desc" | undefined);
     get modelField(): string | number;
-    getOrderBy(_fs: FSPair): model.OrderBy;
+    getOrderBy(_fs: FieldSpace): model.OrderBy;
 }
 export declare class Ordering extends ListOf<OrderBy> {
     constructor(list: OrderBy[]);
-    getOrderBy(fs: FSPair): model.OrderBy[];
+    getOrderBy(fs: FieldSpace): model.OrderBy[];
 }
 export declare class Limit extends MalloyElement {
     readonly limit: number;
@@ -376,8 +376,8 @@ export declare class FullQuery extends TurtleHeadedPipe {
 export declare class TurtleDecl extends TurtleHeadedPipe {
     readonly name: string;
     constructor(name: string);
-    getPipeline(fs: FSPair): model.Pipeline;
-    getFieldDef(inSpace: FieldSpace, nestParent: QuerySpace | undefined): model.TurtleDef;
+    getPipeline(fs: FieldSpace): model.Pipeline;
+    getFieldDef(fs: FieldSpace, nestParent: QuerySpace | undefined): model.TurtleDef;
 }
 export declare class NestReference extends FieldReference {
     readonly name: FieldName;
@@ -422,7 +422,7 @@ export declare class Top extends MalloyElement {
     readonly by?: TopInit | undefined;
     elementType: string;
     constructor(limit: number, by?: TopInit | undefined);
-    getBy(fs: FSPair): model.By | undefined;
+    getBy(fs: FieldSpace): model.By | undefined;
 }
 export declare class JSONElement extends MalloyElement {
     elementType: string;