@malloydata/malloy 0.0.22-dev230207182613 → 0.0.22-dev230207183024

package/dist/lang/ast/sql-elements/sql-statement.js

@@ -30,7 +30,7 @@ class SQLStatement extends malloy_element_1.MalloyElement {
         super();
         this.select = select;
         this.elementType = "sqlStatement";
-        this.has({ select });
+        this.has({ "select": select });
     }
     sqlBlock() {
         if (!this.requestBlock) {
@@ -62,8 +62,8 @@ class SQLStatement extends malloy_element_1.MalloyElement {
             const location = this.select.location;
             const locStruct = {
                 ...lookup.value,
-                fields: lookup.value.fields.map((f) => ({ ...f, location })),
-                location: this.location,
+                "fields": lookup.value.fields.map((f) => ({ ...f, location })),
+                "location": this.location
             };
             if (this.is && !doc.defineSQL(locStruct, this.is)) {
                 this.log(`'${this.is}' already defined`);
@@ -71,8 +71,8 @@ class SQLStatement extends malloy_element_1.MalloyElement {
             return undefined;
         }
         return {
-            compileSQL: sql,
-            partialModel: this.select.containsQueries ? doc.modelDef() : undefined,
+            "compileSQL": sql,
+            "partialModel": this.select.containsQueries ? doc.modelDef() : undefined
         };
     }
 }

package/dist/lang/ast/sql-elements/sql-string.js

@@ -50,7 +50,7 @@ class SQLString extends malloy_element_1.MalloyElement {
     sqlPhrases() {
         return this.elements.map((el) => {
             if (typeof el == "string") {
-                return { sql: el };
+                return { "sql": el };
             }
             return el.query();
         });

package/dist/lang/ast/struct-utils.js

@@ -35,10 +35,10 @@ function opOutputStruct(logTo, inputStruct, opDesc) {
         }
         catch (e) {
             logTo.log(`INTERNAL ERROR model/Segment.nextStructDef: ${e.message}\n` +
-                `QUERY: ${(0, util_1.inspect)(opDesc, { breakLength: 72, depth: Infinity })}`);
+                `QUERY: ${(0, util_1.inspect)(opDesc, { "breakLength": 72, "depth": Infinity })}`);
         }
     }
-    return { ...error_factory_1.ErrorFactory.structDef, dialect: inputStruct.dialect };
+    return { ...error_factory_1.ErrorFactory.structDef, "dialect": inputStruct.dialect };
 }
 exports.opOutputStruct = opOutputStruct;
 function getStructFieldDef(s, fn) {

package/dist/lang/ast/time-utils.js

@@ -27,47 +27,47 @@ const utils_1 = require("./expressions/utils");
 function timeOffset(timeType, from, op, n, timeframe) {
     return [
         {
-            type: "dialect",
-            function: "delta",
-            base: { valueType: timeType, value: from },
+            "type": "dialect",
+            "function": "delta",
+            "base": { "valueType": timeType, "value": from },
             op,
-            delta: n,
-            units: timeframe,
-        },
+            "delta": n,
+            "units": timeframe
+        }
     ];
 }
 exports.timeOffset = timeOffset;
 function castTo(castType, from, safe = false) {
     const cast = {
-        type: "dialect",
-        function: "cast",
-        dstType: castType,
-        expr: from,
-        safe,
+        "type": "dialect",
+        "function": "cast",
+        "dstType": castType,
+        "expr": from,
+        safe
     };
     return [cast];
 }
 exports.castTo = castTo;
 function castTimestampToDate(from, safe = false) {
     const cast = {
-        type: "dialect",
-        function: "cast",
-        dstType: "date",
-        srcType: "timestamp",
-        expr: from,
-        safe,
+        "type": "dialect",
+        "function": "cast",
+        "dstType": "date",
+        "srcType": "timestamp",
+        "expr": from,
+        safe
     };
     return [cast];
 }
 exports.castTimestampToDate = castTimestampToDate;
 function castDateToTimestamp(from, safe = false) {
     const cast = {
-        type: "dialect",
-        function: "cast",
-        dstType: "timestamp",
-        srcType: "date",
-        expr: from,
-        safe,
+        "type": "dialect",
+        "function": "cast",
+        "dstType": "timestamp",
+        "srcType": "date",
+        "expr": from,
+        safe
     };
     return [cast];
 }
@@ -86,18 +86,18 @@ function resolution(timeframe) {
 exports.resolution = resolution;
 function timeResult(t, tt) {
     if (tt) {
-        return { ...t, timeframe: tt };
+        return { ...t, "timeframe": tt };
     }
     return t;
 }
 exports.timeResult = timeResult;
 function timeLiteral(literalStr, timeType, tz) {
     const fragment = {
-        type: "dialect",
-        function: "timeLiteral",
-        literal: literalStr,
-        literalType: timeType,
-        timezone: tz,
+        "type": "dialect",
+        "function": "timeLiteral",
+        "literal": literalStr,
+        "literalType": timeType,
+        "timezone": tz
     };
     return [fragment];
 }
@@ -112,7 +112,7 @@ function timestampOffset(from, op, n, timeframe, fromNotTimestamp = false) {
             ...from,
             `),INTERVAL `,
             ...n,
-            ` ${units}))`,
+            ` ${units}))`
         ];
     }
     const typeFrom = fromNotTimestamp ? ["TIMESTAMP(", ...from, ")"] : from;
@@ -121,7 +121,7 @@ function timestampOffset(from, op, n, timeframe, fromNotTimestamp = false) {
         ...typeFrom,
         `,INTERVAL `,
         ...n,
-        ` ${units})`,
+        ` ${units})`
     ]);
 }
 exports.timestampOffset = timestampOffset;
@@ -133,7 +133,7 @@ function dateOffset(from, op, n, timeframe) {
         ...from,
         `,INTERVAL `,
         ...n,
-        ` ${units})`,
+        ` ${units})`
     ]);
 }
 exports.dateOffset = dateOffset;

package/dist/lang/ast/types/expression-def.js

@@ -90,7 +90,7 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
 exports.ExpressionDef = ExpressionDef;
 class ExprDuration extends ExpressionDef {
     constructor(n, timeframe) {
-        super({ n });
+        super({ "n": n });
         this.n = n;
         this.timeframe = timeframe;
         this.elementType = "duration";
@@ -115,24 +115,24 @@ class ExprDuration extends ExpressionDef {
             if (lhs.dataType === "timestamp") {
                 const result = (0, time_utils_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
                 return (0, time_utils_1.timeResult)({
-                    dataType: "timestamp",
-                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                    value: result,
+                    "dataType": "timestamp",
+                    "expressionType": (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                    "value": result
                 }, resultGranularity);
             }
             return (0, time_utils_1.timeResult)({
-                dataType: "date",
-                expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                value: (0, time_utils_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe),
+                "dataType": "date",
+                "expressionType": (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                "value": (0, time_utils_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe)
             }, resultGranularity);
         }
         return super.apply(fs, op, left);
     }
     getExpression(_fs) {
         return {
-            dataType: "duration",
-            expressionType: "scalar",
-            value: ["__ERROR_DURATION_IS_NOT_A_VALUE__"],
+            "dataType": "duration",
+            "expressionType": "scalar",
+            "value": ["__ERROR_DURATION_IS_NOT_A_VALUE__"]
         };
     }
 }
@@ -158,11 +158,11 @@ function regexEqual(left, right) {
         if (right.dataType === "regular expression") {
             return [
                 {
-                    type: "dialect",
-                    function: "regexpMatch",
-                    expr: left.value,
-                    regexp: right.value[0].replace(/^r'/, "'"),
-                },
+                    "type": "dialect",
+                    "function": "regexpMatch",
+                    "expr": left.value,
+                    "regexp": right.value[0].replace(/^r'/, "'")
+                }
             ];
         }
     }
@@ -170,11 +170,11 @@ function regexEqual(left, right) {
         if (left.dataType === "regular expression") {
             return [
                 {
-                    type: "dialect",
-                    function: "regexpMatch",
-                    expr: right.value,
-                    regexp: left.value[0].replace(/^r'/, "'"),
-                },
+                    "type": "dialect",
+                    "function": "regexpMatch",
+                    "expr": right.value,
+                    "regexp": left.value[0].replace(/^r'/, "'")
+                }
             ];
         }
     }
@@ -229,9 +229,9 @@ function equality(fs, left, op, right) {
         }
     }
     return {
-        dataType: "boolean",
-        expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
-        value,
+        "dataType": "boolean",
+        "expressionType": (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
+        value
     };
 }
 function compare(fs, left, op, right) {
@@ -240,9 +240,9 @@ function compare(fs, left, op, right) {
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     const value = timeCompare(lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
     return {
-        dataType: "boolean",
+        "dataType": "boolean",
         expressionType,
-        value: value,
+        "value": value
     };
 }
 function oneOf(op, ...operators) {
@@ -262,9 +262,9 @@ function numeric(fs, left, op, right) {
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     if (allAre("number", lhs, rhs)) {
         return {
-            dataType: "number",
+            "dataType": "number",
             expressionType,
-            value: (0, utils_1.compose)(lhs.value, op, rhs.value),
+            "value": (0, utils_1.compose)(lhs.value, op, rhs.value)
         };
     }
     left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
@@ -326,15 +326,15 @@ function applyBinary(fs, left, op, right) {
         }
         else {
             const div = {
-                type: "dialect",
-                function: "div",
-                numerator: num.value,
-                denominator: denom.value,
+                "type": "dialect",
+                "function": "div",
+                "numerator": num.value,
+                "denominator": denom.value
             };
             return {
-                dataType: "number",
-                expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
-                value: [div],
+                "dataType": "number",
+                "expressionType": (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
+                "value": [div]
             };
         }
         return (0, ast_utils_1.errorFor)("divide type mismatch");

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

@@ -1,15 +1,15 @@
+import { DocumentLocation, DocumentReference, ModelDef, Query, SQLBlockStructDef } from "../../../model/malloy_types";
 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";
+import { NameSpace } from "./name-space";
 export declare abstract class MalloyElement {
     abstract elementType: string;
     codeLocation?: DocumentLocation;
     children: ElementChildren;
     parent: MalloyElement | null;
-    private logger?;
+    private readonly logger?;
     /**
      * @param kids All children passed to the constructor are not optional
      */
@@ -30,7 +30,7 @@ export declare abstract class MalloyElement {
     addReference(reference: DocumentReference): void;
     private get sourceURL();
     errorsExist(): boolean;
-    private logged;
+    private readonly logged;
     log(message: string): void;
     /**
      * Mostly for debugging / testing. A string-y version of this object which

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

@@ -66,11 +66,11 @@ class MalloyElement {
             return this.parent.location;
         }
         return {
-            url: this.sourceURL,
-            range: {
-                start: { line: 0, character: 0 },
-                end: { line: 0, character: 0 },
-            },
+            "url": this.sourceURL,
+            "range": {
+                "start": { "line": 0, "character": 0 },
+                "end": { "line": 0, "character": 0 }
+            }
         };
     }
     set location(loc) {
@@ -92,27 +92,27 @@ class MalloyElement {
         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,
+                    "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,
+                        "type": "sqlBlockReference",
+                        "text": key,
+                        "definition": result.entry,
+                        "location": reference.location
                     });
                 }
                 else {
                     this.addReference({
-                        type: "exploreReference",
-                        text: key,
-                        definition: result.entry,
-                        location: reference.location,
+                        "type": "exploreReference",
+                        "text": key,
+                        "definition": result.entry,
+                        "location": reference.location
                     });
                 }
             }
@@ -159,7 +159,7 @@ class MalloyElement {
             this.logged.add(message);
         }
         const trans = this.translator();
-        const msg = { at: this.location, message };
+        const msg = { "at": this.location, message };
         const logTo = trans === null || trans === void 0 ? void 0 : trans.root.logger;
         if (logTo) {
             logTo.log(msg);
@@ -332,7 +332,7 @@ class Document extends MalloyElement {
         this.sqlBlocks = [];
         this.didInitModel = false;
         this.statements = new RunList("topLevelStatements", statements);
-        this.has({ statements });
+        this.has({ "statements": statements });
     }
     initModelDef(extendingModelDef) {
         if (this.didInitModel) {
@@ -346,7 +346,7 @@ class Document extends MalloyElement {
                 const struct = extendingModelDef.contents[inName];
                 if (struct.type == "struct") {
                     const exported = extendingModelDef.exports.includes(inName);
-                    this.setEntry(inName, { entry: struct, exported });
+                    this.setEntry(inName, { "entry": struct, exported });
                 }
             }
         }
@@ -355,15 +355,15 @@ class Document extends MalloyElement {
     compile() {
         const needs = this.statements.executeList(this);
         const ret = {
-            modelDef: this.modelDef(),
-            queryList: this.queryList,
-            sqlBlocks: this.sqlBlocks,
-            needs,
+            "modelDef": this.modelDef(),
+            "queryList": this.queryList,
+            "sqlBlocks": this.sqlBlocks,
+            needs
         };
         return ret;
     }
     modelDef() {
-        const def = { name: "", exports: [], contents: {} };
+        const def = { "name": "", "exports": [], "contents": {} };
         for (const entry in this.documentModel) {
             const entryDef = this.documentModel[entry].entry;
             if (entryDef.type === "struct" || entryDef.type === "query") {
@@ -376,13 +376,13 @@ class Document extends MalloyElement {
         return def;
     }
     defineSQL(sql, name) {
-        const ret = { ...sql, as: `$${this.sqlBlocks.length}` };
+        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.setEntry(name, { "entry": ret, "sqlType": true });
         }
         this.sqlBlocks.push(ret);
         return true;

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

@@ -1,4 +1,4 @@
-import { StructDef, Query } from "../../../model/malloy_types";
+import { Query, StructDef } from "../../../model/malloy_types";
 export interface QueryComp {
     outputStruct: StructDef;
     query: Query;

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

@@ -31,7 +31,7 @@ class SpaceField extends space_entry_1.SpaceEntry {
         this.refType = "field";
     }
     fieldTypeFromFieldDef(def) {
-        const ref = { dataType: def.type, expressionType: "scalar" };
+        const ref = { "dataType": def.type, "expressionType": "scalar" };
         if ((0, malloy_types_1.isFieldTypeDef)(def) && def.expressionType) {
             ref.expressionType = def.expressionType;
         }

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

@@ -41,7 +41,7 @@ class AbstractParameter extends SpaceParam {
     }
     typeDesc() {
         const type = this.astParam.type || "unknown";
-        return { dataType: type, expressionType: "scalar" };
+        return { "dataType": type, "expressionType": "scalar" };
     }
 }
 exports.AbstractParameter = AbstractParameter;
@@ -54,7 +54,7 @@ class DefinedParameter extends SpaceParam {
         return this.paramDef;
     }
     typeDesc() {
-        return { dataType: this.paramDef.type, expressionType: "scalar" };
+        return { "dataType": this.paramDef.type, "expressionType": "scalar" };
     }
 }
 exports.DefinedParameter = DefinedParameter;

package/dist/lang/ast/types/turtle-headed-pipe.d.ts

@@ -1,5 +1,5 @@
-import { FieldName } from "./field-space";
 import { PipelineDesc } from "../elements/pipeline-desc";
+import { FieldName } from "./field-space";
 export declare abstract class TurtleHeadedPipe extends PipelineDesc {
     _turtleName?: FieldName;
     set turtleName(turtleName: FieldName | undefined);

package/dist/lang/ast/types/turtle-headed-pipe.js

@@ -27,7 +27,7 @@ const pipeline_desc_1 = require("../elements/pipeline-desc");
 class TurtleHeadedPipe extends pipeline_desc_1.PipelineDesc {
     set turtleName(turtleName) {
         this._turtleName = turtleName;
-        this.has({ turtleName });
+        this.has({ "turtleName": turtleName });
     }
     get turtleName() {
         return this._turtleName;

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

@@ -1,4 +1,4 @@
-import { ExpressionType, AtomicFieldType } from "../../../model/malloy_types";
+import { AtomicFieldType, ExpressionType } from "../../../model/malloy_types";
 export declare type ExpressionValueType = AtomicFieldType | "null" | "unknown" | "duration" | "regular expression";
 export declare type FieldValueType = ExpressionValueType | "turtle" | "struct";
 export interface TypeDesc {

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

@@ -1,4 +1,4 @@
-import { QueryFieldDef, FieldDef } from "../model/malloy_types";
+import { FieldDef, QueryFieldDef } from "../model/malloy_types";
 declare type Field = QueryFieldDef | FieldDef;
 export declare function nameOf(qfd: Field): string;
 export declare function mergeFields<T extends Field>(older: T[] | undefined, newer: T[]): T[];

package/dist/lang/index.d.ts

@@ -1,5 +1,5 @@
 export { MalloyTranslator } from "./parse-malloy";
-export type { UpdateData, SchemaData, URLData, SQLBlockData, } from "./parse-malloy";
+export type { UpdateData, SchemaData, URLData, SQLBlockData } from "./parse-malloy";
 export type { TranslateResponse } from "./translate-response";
 export { exploreQueryWalkerBuilder } from "./parse-tree-walkers/explore-query-walker";
 export type { ExploreClauseRef } from "./parse-tree-walkers/explore-query-walker";

package/dist/lang/malloy-to-ast.d.ts

@@ -1,5 +1,5 @@
 import { ParserRuleContext } from "antlr4ts";
-import type { ParseTree } from "antlr4ts/tree";
+import { ParseTree } from "antlr4ts/tree";
 import { AbstractParseTreeVisitor } from "antlr4ts/tree/AbstractParseTreeVisitor";
 import { MalloyParserVisitor } from "./lib/Malloy/MalloyParserVisitor";
 import * as parse from "./lib/Malloy/MalloyParser";

package/dist/lang/malloy-to-ast.js

@@ -76,19 +76,19 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
      * Log an error message relative to an AST node
      */
     astError(el, str, sev = "error") {
-        this.msgLog.log({ message: str, at: el.location, severity: sev });
+        this.msgLog.log({ "message": str, "at": el.location, "severity": sev });
     }
     /**
      * Log an error message relative to a parse node
      */
     contextError(cx, msg, sev = "error") {
         this.msgLog.log({
-            message: msg,
-            at: {
-                url: this.parse.subTranslator.sourceURL,
-                range: this.parse.subTranslator.rangeFromContext(cx),
+            "message": msg,
+            "at": {
+                "url": this.parse.subTranslator.sourceURL,
+                "range": this.parse.subTranslator.rangeFromContext(cx)
             },
-            severity: sev,
+            "severity": sev
         });
     }
     onlyExploreProperties(els) {
@@ -192,8 +192,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     }
     astAt(el, cx) {
         el.location = {
-            url: this.parse.subTranslator.sourceURL,
-            range: this.parse.subTranslator.rangeFromContext(cx),
+            "url": this.parse.subTranslator.sourceURL,
+            "range": this.parse.subTranslator.rangeFromContext(cx)
         };
         return el;
     }
@@ -976,14 +976,14 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     visitSampleStatement(pcx) {
         const rowCx = pcx.sampleSpec().INTEGER_LITERAL();
         if (rowCx) {
-            return new ast.SampleProperty({ rows: this.getNumber(rowCx) });
+            return new ast.SampleProperty({ "rows": this.getNumber(rowCx) });
         }
         const limitCx = pcx.sampleSpec().PERCENT_LITERAL();
         if (limitCx) {
-            return new ast.SampleProperty({ percent: this.getNumber(limitCx) });
+            return new ast.SampleProperty({ "percent": this.getNumber(limitCx) });
         }
         const enabled = pcx.sampleSpec().TRUE() != undefined;
-        return new ast.SampleProperty({ enable: enabled });
+        return new ast.SampleProperty({ "enable": enabled });
     }
 }
 exports.MalloyToAST = MalloyToAST;

package/dist/lang/parse-error-handler.js

@@ -29,13 +29,13 @@ class MalloyParserErrorHandler {
         this.messages = messages;
     }
     syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, _e) {
-        const errAt = { line: line - 1, character: charPositionInLine };
+        const errAt = { "line": line - 1, "character": charPositionInLine };
         const range = offendingSymbol
             ? this.translator.rangeFromToken(offendingSymbol)
-            : { start: errAt, end: errAt };
+            : { "start": errAt, "end": errAt };
         const error = {
-            message: msg,
-            at: { url: this.translator.sourceURL, range },
+            "message": msg,
+            "at": { "url": this.translator.sourceURL, range }
         };
         this.messages.log(error);
     }

package/dist/lang/parse-malloy.d.ts

@@ -1,10 +1,10 @@
-import { Token, CommonTokenStream, ParserRuleContext, CodePointCharStream } from "antlr4ts";
-import type { ParseTree } from "antlr4ts/tree";
-import { Query, NamedStructDefs, StructDef, ModelDef, DocumentReference, DocumentPosition, DocumentLocation, DocumentRange, SQLBlockStructDef } from "../model/malloy_types";
+import { CodePointCharStream, CommonTokenStream, ParserRuleContext, Token } from "antlr4ts";
+import { ParseTree } from "antlr4ts/tree";
+import { DocumentLocation, DocumentPosition, DocumentRange, DocumentReference, ModelDef, NamedStructDefs, Query, SQLBlockStructDef, StructDef } from "../model/malloy_types";
 import { MessageLog } from "./parse-log";
 import { Zone, ZoneData } from "./zone";
 import { ReferenceList } from "./reference-list";
-import { ErrorResponse, NeedURLData, FinalResponse, DataRequestResponse, ASTResponse, MetadataResponse, CompletionsResponse, HelpContextResponse, TranslateResponse, FatalResponse, ModelDataRequest } from "./translate-response";
+import { ASTResponse, CompletionsResponse, DataRequestResponse, ErrorResponse, FatalResponse, FinalResponse, HelpContextResponse, MetadataResponse, ModelDataRequest, NeedURLData, TranslateResponse } from "./translate-response";
 export declare type StepResponses = DataRequestResponse | ASTResponse | TranslateResponse | ParseResponse | MetadataResponse;
 /**
  * A Translation is a series of translation steps. Each step can depend