@malloydata/malloy 0.0.1

package/dist/malloy.d.ts

@@ -0,0 +1,1134 @@
+/// <reference types="node" />
+import { InfoConnection } from ".";
+import { DocumentHighlight as DocumentHighlightDefinition, DocumentSymbol as DocumentSymbolDefinition, DocumentCompletion as DocumentCompletionDefinition, LogMessage, MalloyTranslator } from "./lang";
+import { DocumentHelpContext } from "./lang/parse-tree-walkers/document-help-context-walker";
+import { CompiledQuery, FieldBooleanDef, FieldDateDef, FieldNumberDef, FieldStringDef, FieldTimestampDef, FieldTypeDef, FilterExpression, ModelDef, Query as InternalQuery, QueryData, QueryDataRow, QueryResult, StructDef, TurtleDef, SQLBlock, DocumentReference, DocumentPosition as ModelDocumentPosition, SearchIndexResult, SearchValueMapResult } from "./model";
+import { LookupConnection, ModelString, ModelURL, QueryString, QueryURL, URLReader, Connection } from "./runtime_types";
+export interface Loggable {
+    debug: (message?: any, ...optionalParams: any[]) => void;
+    info: (message?: any, ...optionalParams: any[]) => void;
+    warn: (message?: any, ...optionalParams: any[]) => void;
+    error: (message?: any, ...optionalParams: any[]) => void;
+}
+export interface RunSQLOptions {
+    rowLimit?: number;
+}
+export declare class Malloy {
+    static get version(): string;
+    private static _log;
+    static get log(): Loggable;
+    static setLogger(log: Loggable): void;
+    private static _parse;
+    /**
+     * Parse a Malloy document by URL.
+     *
+     * @param url The URL of the Malloy document to parse.
+     * @param urlReader Object capable of fetching URL contents.
+     * @returns A (promise of a) `Parse` result.
+     */
+    static parse({ url, urlReader, }: {
+        url: URL;
+        urlReader: URLReader;
+    }): Promise<Parse>;
+    /**
+     * Parse a Malloy document by contents.
+     *
+     * @param url The URL of the Malloy document to parse (optional).
+     * @param source The contents of the Malloy document to parse.
+     * @returns A `Parse` result.
+     */
+    static parse({ source, url }: {
+        url?: URL;
+        source: string;
+    }): Parse;
+    /**
+     * Compile a parsed Malloy document.
+     *
+     * @param urlReader Object capable of reading contents of a URL.
+     * @param connections Mapping of connection names to objects capable of reading Malloy schemas.
+     * @param parse The parsed Malloy document.
+     * @param model A compiled model to build upon (optional).
+     * @returns A (promise of a) compiled `Model`.
+     */
+    static compile({ urlReader, connections, parse, model, }: {
+        urlReader: URLReader;
+        connections: LookupConnection<InfoConnection>;
+        parse: Parse;
+        model?: Model;
+    }): Promise<Model>;
+    private static runSQLBlockAndFetchResultSchema;
+    /**
+     * Run a fully-prepared query.
+     *
+     * @param get A mapping from connection names to objects capable of running SQL.
+     * @param preparedResult A fully-prepared query which is ready to run (a `PreparedResult`).
+     * @returns Query result data and associated metadata.
+     */
+    static run(params: {
+        connections: LookupConnection<Connection>;
+        preparedResult: PreparedResult;
+        options?: RunSQLOptions;
+    }): Promise<Result>;
+    static run(params: {
+        connection: Connection;
+        preparedResult: PreparedResult;
+        options?: RunSQLOptions;
+    }): Promise<Result>;
+    static run(params: {
+        connection: Connection;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): Promise<Result>;
+    static run(params: {
+        connections: LookupConnection<Connection>;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): Promise<Result>;
+    static run(params: {
+        connection: Connection;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): Promise<Result>;
+    static run(params: {
+        connections: LookupConnection<Connection>;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): Promise<Result>;
+    static runStream(params: {
+        connections: LookupConnection<Connection>;
+        preparedResult: PreparedResult;
+        options?: RunSQLOptions;
+    }): AsyncIterableIterator<DataRecord>;
+    static runStream(params: {
+        connection: Connection;
+        preparedResult: PreparedResult;
+        options?: RunSQLOptions;
+    }): AsyncIterableIterator<DataRecord>;
+    static runStream(params: {
+        connection: Connection;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): AsyncIterableIterator<DataRecord>;
+    static runStream(params: {
+        connections: LookupConnection<Connection>;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): AsyncIterableIterator<DataRecord>;
+    static runStream(params: {
+        connection: Connection;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): AsyncIterableIterator<DataRecord>;
+    static runStream(params: {
+        connections: LookupConnection<Connection>;
+        sqlBlock: SQLBlock;
+        options?: RunSQLOptions;
+    }): AsyncIterableIterator<DataRecord>;
+}
+/**
+ * A Malloy error, which may contain log messages produced during compilation.
+ */
+export declare class MalloyError extends Error {
+    /**
+     * An array of log messages produced during compilation.
+     */
+    readonly log: LogMessage[];
+    constructor(message: string, log?: LogMessage[]);
+}
+/**
+ * A compiled Malloy document.
+ */
+export declare class Model {
+    private modelDef;
+    private queryList;
+    private sqlBlocks;
+    _referenceAt: (location: ModelDocumentPosition) => DocumentReference | undefined;
+    constructor(modelDef: ModelDef, queryList: InternalQuery[], sqlBlocks: SQLBlock[], referenceAt?: (location: ModelDocumentPosition) => DocumentReference | undefined);
+    /**
+     * Retrieve a document reference for the token at the given position within
+     * the document that produced this model.
+     *
+     * @param position A position within the document.
+     * @returns A `DocumentReference` at that position if one exists.
+     */
+    getReference(position: ModelDocumentPosition): DocumentReference | undefined;
+    /**
+     * Retrieve a prepared query by the name of a query at the top level of the model.
+     *
+     * @param queryName Name of the query to retrieve.
+     * @returns A prepared query.
+     */
+    getPreparedQueryByName(queryName: string): PreparedQuery;
+    /**
+     * Retrieve a prepared query by the index of an unnamed query at the top level of a model.
+     *
+     * @param index The index of the query to retrieve.
+     * @returns A prepared query.
+     */
+    getPreparedQueryByIndex(index: number): PreparedQuery;
+    /**
+     * Retrieve a prepared query by the name of a query at the top level of the model.
+     *
+     * @param queryName Name of the query to retrieve.
+     * @returns A prepared query.
+     */
+    getSQLBlockByName(sqlBlockName: string): SQLBlock;
+    /**
+     * Retrieve a prepared query by the name of a query at the top level of the model.
+     *
+     * @param index Index of the SQL Block to retrieve.
+     * @returns A prepared query.
+     */
+    getSQLBlockByIndex(index: number): SQLBlock;
+    /**
+     * Retrieve a prepared query for the final unnamed query at the top level of a model.
+     *
+     * @returns A prepared query.
+     */
+    get preparedQuery(): PreparedQuery;
+    /**
+     * Retrieve an `Explore` from the model by name.
+     *
+     * @param name The name of the `Explore` to retrieve.
+     * @returns An `Explore`.
+     */
+    getExploreByName(name: string): Explore;
+    /**
+     * Get an array of `Explore`s contained in the model.
+     *
+     * @returns An array of `Explore`s contained in the model.
+     */
+    get explores(): Explore[];
+    get exportedExplores(): Explore[];
+    get _modelDef(): ModelDef;
+}
+/**
+ * A prepared query which has all the necessary information to produce its SQL.
+ */
+export declare class PreparedQuery {
+    private _modelDef;
+    private _query;
+    private name?;
+    constructor(query: InternalQuery, model: ModelDef, name?: string);
+    /**
+     * Generate the SQL for this query.
+     *
+     * @returns A fully-prepared query (which contains the generated SQL).
+     */
+    get preparedResult(): PreparedResult;
+    get dialect(): string;
+}
+export declare function parseTableURL(tableURL: string): {
+    connectionName?: string;
+    tablePath: string;
+};
+/**
+ * A parsed Malloy document.
+ */
+export declare class Parse {
+    private translator;
+    constructor(translator: MalloyTranslator);
+    /**
+     * Retrieve the document highlights for the parsed document.
+     *
+     * These highlights represent the parsed tokens contained in the document,
+     * and may be used for syntax highlighting in an IDE, for example.
+     *
+     * @returns An array of document highlights.
+     */
+    get highlights(): DocumentHighlight[];
+    /**
+     * Retrieve the symbols defined in the parsed document.
+     *
+     * These symbols represent any object defined (e.g. `Query`s and `Explore`s)
+     * in the document.
+     *
+     * @returns An array of document symbols.
+     */
+    get symbols(): DocumentSymbol[];
+    get _translator(): MalloyTranslator;
+    completions(position: {
+        line: number;
+        character: number;
+    }): DocumentCompletion[];
+    helpContext(position: {
+        line: number;
+        character: number;
+    }): DocumentHelpContext | undefined;
+}
+/**
+ * A document highlight.
+ *
+ * Represents a parsed token contained in a Malloy document
+ * and may be used for syntax highlighting in an IDE, for example.
+ */
+export declare class DocumentHighlight {
+    private _range;
+    private _type;
+    constructor(documentHighlight: DocumentHighlightDefinition);
+    /**
+     * @returns The range of characters this highlight spans within its source document.
+     */
+    get range(): DocumentRange;
+    /**
+     * @returns The type of highlight, which may be any `HighlightType`.
+     */
+    get type(): string;
+}
+/**
+ * A range of characters within a Malloy document.
+ */
+export declare class DocumentRange {
+    private _start;
+    private _end;
+    constructor(start: DocumentPosition, end: DocumentPosition);
+    /**
+     * @returns The position of the first character in the range.
+     */
+    get start(): DocumentPosition;
+    /**
+     * @returns The position of the last character in the range.
+     */
+    get end(): DocumentPosition;
+    /**
+     * @returns This range in JSON format.
+     */
+    toJSON(): {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}
+/**
+ * A position within a Malloy document.
+ */
+export declare class DocumentPosition {
+    private _line;
+    private _character;
+    constructor(line: number, character: number);
+    /**
+     * @returns The line number of the position.
+     */
+    get line(): number;
+    /**
+     * @returns The character index on the line `this.getLine()`.
+     */
+    get character(): number;
+    /**
+     * @returns This position in JSON format.
+     */
+    toJSON(): {
+        line: number;
+        character: number;
+    };
+}
+/**
+ * A symbol defined in a Malloy document.
+ *
+ * Represents any object defined (e.g. `Query`s and `Explore`s) in the document.
+ */
+export declare class DocumentSymbol {
+    private _range;
+    private _type;
+    private _name;
+    private _children;
+    constructor(documentSymbol: DocumentSymbolDefinition);
+    /**
+     * @returns The range of characters in the source Malloy document that define this symbol.
+     */
+    get range(): DocumentRange;
+    /**
+     * @returns The type of symbol.
+     *
+     * Possible values are: `"explore"`, `"query"`, `"field"`, `"turtle"`, `"join"`, or `"unnamed_query"`.
+     */
+    get type(): string;
+    /**
+     * @returns The name of this symbol, e.g. the `Explore` name or `Query` name.
+     *
+     * For type `"unnamed_query"`, `getName()` is `"unnamed_query"`.
+     */
+    get name(): string;
+    /**
+     * @returns An array of document symbols defined inside this document symbol,
+     * e.g. fields in an `Explore`.
+     */
+    get children(): DocumentSymbol[];
+}
+export declare class DocumentCompletion {
+    readonly type: string;
+    readonly text: string;
+    constructor(completion: DocumentCompletionDefinition);
+}
+/**
+ * A fully-prepared query containing SQL and metadata required to run the query.
+ */
+export declare class PreparedResult {
+    protected inner: CompiledQuery;
+    protected modelDef: ModelDef;
+    constructor(query: CompiledQuery, modelDef: ModelDef);
+    /**
+     * @returns The name of the connection this query should be run against.
+     */
+    get connectionName(): string;
+    get _rawQuery(): CompiledQuery;
+    get _modelDef(): ModelDef;
+    /**
+     * @returns The SQL that should be run against the SQL runner
+     * with the connection name `this.getConnectionName()`.
+     */
+    get sql(): string;
+    /**
+     * @returns The `Explore` representing the data that will be returned by running this query.
+     */
+    get resultExplore(): Explore;
+    get sourceExplore(): Explore;
+    get _sourceExploreName(): string;
+    get _sourceFilters(): FilterExpression[];
+}
+/**
+ * A URL reader which always throws an error when a URL's contents is requested.
+ *
+ * Useful for scenarios in which `import` statements are not required.
+ */
+export declare class EmptyURLReader implements URLReader {
+    readURL(_url: URL): Promise<string>;
+}
+/**
+ * A URL reader backed by an in-memory mapping of URL contents.
+ */
+export declare class InMemoryURLReader implements URLReader {
+    private files;
+    constructor(files: Map<string, string>);
+    readURL(url: URL): Promise<string>;
+}
+/**
+ * A fixed mapping of connection names to connections.
+ */
+export declare class FixedConnectionMap implements LookupConnection<Connection> {
+    private connections;
+    private defaultConnectionName?;
+    constructor(connections: Map<string, Connection>, defaultConnectionName?: string);
+    /**
+     * Get a connection by name.
+     *
+     * @param connectionName The name of the connection to look up.
+     * @returns A `Connection`
+     * @throws An `Error` if no connection with the given name exists.
+     */
+    getConnection(connectionName?: string): Promise<Connection>;
+    lookupConnection(connectionName?: string): Promise<Connection>;
+    static fromArray(connections: Connection[]): FixedConnectionMap;
+}
+/**
+ * The relationship of an `Explore` to its source.
+ */
+export declare enum SourceRelationship {
+    /**
+     * The `Explore` is nested data within the source's rows.
+     */
+    Nested = "nested",
+    /**
+     * The `Explore` is the base table.
+     */
+    BaseTable = "base_table",
+    /**
+     * The `Explore` is joined to its source
+     */
+    Cross = "cross",
+    One = "one",
+    Many = "many",
+    Inline = "inline"
+}
+declare abstract class Entity {
+    private readonly _name;
+    protected readonly _parent?: Explore;
+    private readonly _source?;
+    constructor(name: string, parent?: Explore, source?: Entity);
+    get source(): Entity | undefined;
+    get name(): string;
+    get sourceClasses(): string[];
+    hasParentExplore(): this is Field;
+    isExplore(): this is Explore;
+    isQuery(): this is Query;
+    abstract isIntrinsic(): boolean;
+}
+export declare type Field = AtomicField | QueryField | ExploreField;
+export declare class Explore extends Entity {
+    protected readonly _structDef: StructDef;
+    protected readonly _parentExplore?: Explore;
+    private _fieldMap;
+    private sourceExplore;
+    constructor(structDef: StructDef, parentExplore?: Explore, source?: Explore);
+    get source(): Explore | undefined;
+    isIntrinsic(): boolean;
+    /**
+     * @returns The name of the entity.
+     */
+    get name(): string;
+    getQueryByName(name: string): PreparedQuery;
+    private get modelDef();
+    getSingleExploreModel(): Model;
+    private get fieldMap();
+    get allFields(): Field[];
+    get intrinsicFields(): Field[];
+    getFieldByName(fieldName: string): Field;
+    getFieldByNameIfExists(fieldName: string): Field | undefined;
+    get primaryKey(): string | undefined;
+    get parentExplore(): Explore | undefined;
+    get sourceRelationship(): SourceRelationship;
+    hasParentExplore(): this is ExploreField;
+    get filters(): FilterExpression[];
+    get limit(): number | undefined;
+    get structDef(): StructDef;
+}
+export declare enum AtomicFieldType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Date = "date",
+    Timestamp = "timestamp"
+}
+export declare class AtomicField extends Entity {
+    protected fieldTypeDef: FieldTypeDef;
+    protected parent: Explore;
+    constructor(fieldTypeDef: FieldTypeDef, parent: Explore, source?: AtomicField);
+    get type(): AtomicFieldType;
+    isIntrinsic(): boolean;
+    isQueryField(): this is QueryField;
+    isExploreField(): this is ExploreField;
+    isAtomicField(): this is AtomicField;
+    isAggregate(): boolean;
+    get sourceField(): Field;
+    get sourceClasses(): string[];
+    sourceWasMeasure(): boolean;
+    sourceWasMeasureLike(): boolean;
+    sourceWasDimension(): boolean;
+    hasParentExplore(): this is Field;
+    isString(): this is StringField;
+    isNumber(): this is NumberField;
+    isDate(): this is DateField;
+    isBoolean(): this is BooleanField;
+    isTimestamp(): this is TimestampField;
+    get parentExplore(): Explore;
+    get expression(): string;
+}
+export declare enum DateTimeframe {
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Quarter = "quarter",
+    Year = "year"
+}
+export declare enum TimestampTimeframe {
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Quarter = "quarter",
+    Year = "year",
+    Second = "second",
+    Hour = "hour",
+    Minute = "minute"
+}
+export declare class DateField extends AtomicField {
+    private fieldDateDef;
+    constructor(fieldDateDef: FieldDateDef, parent: Explore, source?: AtomicField);
+    get timeframe(): DateTimeframe | undefined;
+}
+export declare class TimestampField extends AtomicField {
+    private fieldTimestampDef;
+    constructor(fieldTimestampDef: FieldTimestampDef, parent: Explore, source?: AtomicField);
+    get timeframe(): TimestampTimeframe | undefined;
+}
+export declare class NumberField extends AtomicField {
+    private fieldNumberDef;
+    constructor(fieldNumberDef: FieldNumberDef, parent: Explore, source?: AtomicField);
+}
+export declare class BooleanField extends AtomicField {
+    private fieldBooleanDef;
+    constructor(fieldBooleanDef: FieldBooleanDef, parent: Explore, source?: AtomicField);
+}
+export declare class StringField extends AtomicField {
+    private fieldStringDef;
+    constructor(fieldStringDef: FieldStringDef, parent: Explore, source?: AtomicField);
+}
+export declare class Query extends Entity {
+    protected turtleDef: TurtleDef;
+    private sourceQuery?;
+    constructor(turtleDef: TurtleDef, parent?: Explore, source?: Query);
+    get source(): Query | undefined;
+    isIntrinsic(): boolean;
+}
+export declare class QueryField extends Query {
+    protected parent: Explore;
+    constructor(turtleDef: TurtleDef, parent: Explore, source?: Query);
+    isQueryField(): this is QueryField;
+    isExploreField(): this is ExploreField;
+    isAtomicField(): this is AtomicField;
+    get sourceClasses(): string[];
+    hasParentExplore(): this is Field;
+    get parentExplore(): Explore;
+    get expression(): string;
+}
+export declare enum JoinRelationship {
+    OneToOne = "one_to_one",
+    OneToMany = "one_to_many",
+    ManyToOne = "many_to_one"
+}
+export declare class ExploreField extends Explore {
+    protected _parentExplore: Explore;
+    constructor(structDef: StructDef, parentExplore: Explore, source?: Explore);
+    get joinRelationship(): JoinRelationship;
+    isQueryField(): this is QueryField;
+    isExploreField(): this is ExploreField;
+    isAtomicField(): this is AtomicField;
+    get parentExplore(): Explore;
+    get sourceClasses(): string[];
+}
+/**
+ * An environment for compiling and running Malloy queries.
+ */
+export declare class Runtime {
+    private _urlReader;
+    private _connections;
+    constructor(runtime: LookupConnection<Connection> & URLReader);
+    constructor(urls: URLReader, connections: LookupConnection<Connection>);
+    constructor(urls: URLReader, connection: Connection);
+    constructor(connection: Connection);
+    constructor(connections: LookupConnection<Connection>);
+    /**
+     * @returns The `URLReader` for this runtime instance.
+     */
+    get urlReader(): URLReader;
+    /**
+     * @returns The `LookupConnection<Connection>` for this runtime instance.
+     */
+    get connections(): LookupConnection<Connection>;
+    /**
+     * Load a Malloy model by URL or contents.
+     *
+     * @param source The model URL or contents to load and (eventually) compile.
+     * @returns A `ModelMaterializer` capable of materializing the requested model,
+     * or loading further related objects.
+     */
+    loadModel(source: ModelURL | ModelString): ModelMaterializer;
+    _loadModelFromModelDef(modelDef: ModelDef): ModelMaterializer;
+    /**
+     * Load a Malloy query by URL or contents.
+     *
+     * @param query The query URL or contents to load and (eventually) compile.
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadQuery(query: QueryURL | QueryString): QueryMaterializer;
+    /**
+     * Load a Malloy query by the URL or contents of a Malloy model document
+     * and the index of an unnamed query contained in the model.
+     *
+     * @param model The model URL or contents to load and (eventually) compile to retrieve the requested query.
+     * @param index The index of the query to use within the model.
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadQueryByIndex(model: ModelURL | ModelString, index: number): QueryMaterializer;
+    /**
+     * Load a Malloy query by the URL or contents of a Malloy model document
+     * and the name of a query contained in the model.
+     *
+     * @param model The model URL or contents to load and (eventually) compile to retrieve the requested query.
+     * @param name The name of the query to use within the model.
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadQueryByName(model: ModelURL | ModelString, name: string): QueryMaterializer;
+    /**
+     * Load a SQL block by the URL or contents of a Malloy model document
+     * and the name of a query contained in the model.
+     *
+     * @param model The model URL or contents to load and (eventually) compile to retrieve the requested query.
+     * @param name The name of the sql block to use within the model.
+     * @returns A `SQLBlockMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadSQLBlockByName(model: ModelURL | ModelString, name: string): SQLBlockMaterializer;
+    /**
+     * Load a SQL block by the URL or contents of a Malloy model document
+     * and the name of a query contained in the model.
+     *
+     * @param model The model URL or contents to load and (eventually) compile to retrieve the requested query.
+     * @param index The index of the SQL block to use within the model. Note: named blocks are indexable, too.
+     * @returns A `SQLBlockMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadSQLBlockByIndex(model: ModelURL | ModelString, index: number): SQLBlockMaterializer;
+    /**
+     * Compile a Malloy model by URL or contents.
+     *
+     * @param source The URL or contents of a Malloy model document to compile.
+     * @returns A promise of a compiled `Model`.
+     */
+    getModel(source: ModelURL | ModelString): Promise<Model>;
+    /**
+     * Compile a Malloy query by URL or contents.
+     *
+     * @param query The URL or contents of a Malloy query document to compile.
+     * @returns A promise of a compiled `PreparedQuery`.
+     */
+    getQuery(query: QueryURL | QueryString): Promise<PreparedQuery>;
+    /**
+     * Compile a Malloy query by the URL or contents of a model document
+     * and the index of an unnamed query contained within the model.
+     *
+     * @param model The URL or contents of a Malloy model document to compile.
+     * @param index The index of an unnamed query contained within the model.
+     * @returns A promise of a compiled `PreparedQuery`.
+     */
+    getQueryByIndex(model: ModelURL | ModelString, index: number): Promise<PreparedQuery>;
+    /**
+     * Compile a Malloy query by the URL or contents of a model document
+     * and the name of a query contained within the model.
+     *
+     * @param model The URL or contents of a Malloy model document to compile.
+     * @param name The name of a query contained within the model.
+     * @returns A promise of a compiled `PreparedQuery`.
+     */
+    getQueryByName(model: ModelURL | ModelString, name: string): Promise<PreparedQuery>;
+    /**
+     * Get a SQL block by the URL or contents of a Malloy model document
+     * and the name of a SQL block contained in the model.
+     *
+     * @param model The model URL or contents to load and (eventually) compile to retrieve the requested query.
+     * @param name The name of the sql block to use within the model.
+     * @returns A promise of a `SQLBlock`.
+     */
+    getSQLBlockByName(model: ModelURL | ModelString, name: string): Promise<SQLBlock>;
+    /**
+     * Get a SQL block by the URL or contents of a Malloy model document
+     * and the name of a query contained in the model.
+     *
+     * @param model The model URL or contents to load and (eventually) compile to retrieve the requested query.
+     * @param index The index of the SQL block to use within the model. Note: named blocks are indexable, too.
+     * @returns A promise of a `SQLBlock`.
+     */
+    getSQLBlockByIndex(model: ModelURL | ModelString, index: number): Promise<SQLBlock>;
+}
+export declare class ConnectionRuntime extends Runtime {
+    readonly rawConnections: Connection[];
+    constructor(urls: URLReader, connections: Connection[]);
+    constructor(connections: Connection[]);
+}
+export declare class SingleConnectionRuntime<T extends Connection = Connection> extends Runtime {
+    readonly connection: T;
+    constructor(urls: URLReader, connection: T);
+    constructor(connection: T);
+}
+declare class FluentState<T> {
+    protected runtime: Runtime;
+    private readonly _materialize;
+    private materialized;
+    constructor(runtime: Runtime, materialize: () => Promise<T>);
+    protected materialize(): Promise<T>;
+    protected rematerialize(): Promise<T>;
+    protected makeQueryMaterializer(materialize: () => Promise<PreparedQuery>): QueryMaterializer;
+    protected makeExploreMaterializer(materialize: () => Promise<Explore>): ExploreMaterializer;
+    protected makePreparedResultMaterializer(materialize: () => Promise<PreparedResult>): PreparedResultMaterializer;
+    protected makeSQLBlockMaterializer(materialize: () => Promise<SQLBlock>): SQLBlockMaterializer;
+}
+/**
+ * An object representing the task of loading a `Model`, capable of
+ * materializing that model (via `getModel()`) or extending the task to load
+ * queries or explores (via e.g. `loadFinalQuery()`, `loadQuery`, `loadExploreByName`, etc.).
+ */
+export declare class ModelMaterializer extends FluentState<Model> {
+    /**
+     * Load the final (unnamed) Malloy query contained within this loaded `Model`.
+     *
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadFinalQuery(): QueryMaterializer;
+    /**
+     * Load an unnamed query contained within this loaded `Model` by index.
+     *
+     * @param index The index of the query to load.
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadQueryByIndex(index: number): QueryMaterializer;
+    /**
+     * Load a query contained within this loaded `Model` by its name.
+     *
+     * @param name The name of the query to load.
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadQueryByName(name: string): QueryMaterializer;
+    /**
+     * Load a query against this loaded `Model` by its URL or contents.
+     *
+     * @param query The URL or contents of the query to load and (eventually) compile.
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadQuery(query: QueryString | QueryURL): QueryMaterializer;
+    search(sourceName: string, searchTerm: string, limit?: number, searchField?: string | undefined): Promise<SearchIndexResult[] | undefined>;
+    searchValueMap(sourceName: string, limit?: number): Promise<SearchValueMapResult[] | undefined>;
+    /**
+     * Load a SQL Block by name.
+     *
+     * @param name The name of the SQL Block to load.
+     * @returns A `SQLBlockMaterializer` capable of materializing the requested sql block, running it,
+     * or loading further related objects.
+     */
+    loadSQLBlockByName(name: string): SQLBlockMaterializer;
+    /**
+     * Load a SQL Block by index.
+     *
+     * @param index The index of the SQL Block to load. Note: named SQL blocks are indexable, too.
+     * @returns A `SQLBlockMaterializer` capable of materializing the requested sql block, running it,
+     * or loading further related objects.
+     *
+     * TODO feature-sql-block Should named SQL blocks be indexable? This is not the way unnamed queries work.
+     */
+    loadSQLBlockByIndex(index: number): SQLBlockMaterializer;
+    /**
+     * Materialize the final query contained within this loaded `Model`.
+     *
+     * @returns A promise to a prepared query.
+     */
+    getFinalQuery(): Promise<PreparedQuery>;
+    /**
+     * Materialize an unnamed query contained within this loaded `Model` by index.
+     *
+     * @param index The index of the query contained within this loaded `Model`.
+     * @returns A promise to a prepared query.
+     */
+    getQueryByIndex(index: number): Promise<PreparedQuery>;
+    /**
+     * Materialize a query contained within this loaded `Model` by name.
+     *
+     * @param name The name of the query contained within this loaded `Model`.
+     * @returns A promise to a prepared query.
+     */
+    getQueryByName(name: string): Promise<PreparedQuery>;
+    /**
+     * Materialize a query against this loaded `Model` by its URL or contents.
+     *
+     * @param query The URL or contents of a query document to compile.
+     * @returns A promise to a prepared query.
+     */
+    getQuery(query: QueryString | QueryURL): Promise<PreparedQuery>;
+    /**
+     * Get a SQL Block by name.
+     *
+     * @param name The name of the SQL Block to load.
+     * @returns A promise of a `SQLBlock`.
+     */
+    getSQLBlockByName(name: string): Promise<SQLBlock>;
+    /**
+     * Get a SQL Block by index.
+     *
+     * @param index The index of the SQL Block to load. Note: named SQL blocks are indexable, too.
+     * @returns A promise of a `SQLBlock`.
+     *
+     * TODO feature-sql-block Should named SQL blocks be indexable? This is not the way unnamed queries work.
+     */
+    getSQLBlockByIndex(index: number): Promise<SQLBlock>;
+    _loadQueryFromQueryDef(query: InternalQuery): QueryMaterializer;
+    /**
+     * Load an explore contained within this loaded `Model` by name.
+     *
+     * @param name The name of the explore contained within this loaded `Model`.
+     * @returns An `ExploreMaterializer` capable of materializing the requested explore,
+     * or loading further related objects.
+     */
+    loadExploreByName(name: string): ExploreMaterializer;
+    /**
+     * Materialize an explore contained within this loaded `Model` by its name.
+     *
+     * @param query The name of an explore within this loaded `Model`.
+     * @returns A promise to an explore.
+     */
+    getExploreByName(name: string): Promise<Explore>;
+    /**
+     * Compile and materialize this loaded `Model`.
+     *
+     * @returns A promise to the compiled model that is loaded.
+     */
+    getModel(): Promise<Model>;
+}
+/**
+ * An object representing the task of loading a `Query`, capable of
+ * materializing the query (via `getPreparedQuery()`) or extending the task to load
+ * prepared results or run the query (via e.g. `loadPreparedResult()` or `run()`).
+ */
+export declare class QueryMaterializer extends FluentState<PreparedQuery> {
+    /**
+     * Run this loaded `Query`.
+     *
+     * @returns The query results from running this loaded query.
+     */
+    run(options?: RunSQLOptions): Promise<Result>;
+    runStream(options?: {
+        rowLimit?: number;
+    }): AsyncIterableIterator<DataRecord>;
+    /**
+     * Load the prepared result of this loaded query.
+     *
+     * @returns A `PreparedResultMaterializer` capable of materializing the requested
+     * prepared query or running it.
+     */
+    loadPreparedResult(): PreparedResultMaterializer;
+    /**
+     * Materialize the prepared result of this loaded query.
+     *
+     * @returns A promise of the prepared result of this loaded query.
+     */
+    getPreparedResult(): Promise<PreparedResult>;
+    /**
+     * Materialize the SQL of this loaded query.
+     *
+     * @returns A promise of the SQL string.
+     */
+    getSQL(): Promise<string>;
+    /**
+     * Materialize this loaded query.
+     *
+     * @returns A promise of the `PreparedQuery`.
+     */
+    getPreparedQuery(): Promise<PreparedQuery>;
+}
+/**
+ * An object representing the task of loading a `PreparedResult`, capable of
+ * materializing the prepared result (via `getPreparedResult()`) or extending the task run
+ * the query.
+ */
+export declare class PreparedResultMaterializer extends FluentState<PreparedResult> {
+    /**
+     * Run this prepared result.
+     *
+     * @returns A promise to the query result data.
+     */
+    run(options?: RunSQLOptions): Promise<Result>;
+    runStream(options?: {
+        rowLimit?: number;
+    }): AsyncIterableIterator<DataRecord>;
+    /**
+     * Materialize this loaded prepared result.
+     *
+     * @returns A promise of a prepared result.
+     */
+    getPreparedResult(): Promise<PreparedResult>;
+    /**
+     * Materialize the SQL of this loaded prepared result.
+     *
+     * @returns A promise to the SQL string.
+     */
+    getSQL(): Promise<string>;
+}
+/**
+ * An object representing the task of loading a `SQLBlock`, capable of
+ * materializing the SQLBlock (via `getSQLBlock()`) or extending the task run
+ * the query.
+ */
+export declare class SQLBlockMaterializer extends FluentState<SQLBlock> {
+    /**
+     * Run this SQL block.
+     *
+     * @returns A promise to the query result data.
+     */
+    run(options?: RunSQLOptions): Promise<Result>;
+    runStream(options?: {
+        rowLimit?: number;
+    }): AsyncIterableIterator<DataRecord>;
+    /**
+     * Materialize this loaded SQL block.
+     *
+     * @returns A promise of a SQL block.
+     */
+    getSQLBlock(): Promise<SQLBlock>;
+    /**
+     * Materialize the SQL of this loaded SQL block.
+     *
+     * @returns A promise to the SQL string.
+     */
+    getSQL(): Promise<string>;
+}
+/**
+ * An object representing the task of loading an `Explore`, capable of
+ * materializing the explore (via `getExplore()`) or extending the task to produce
+ * related queries.
+ */
+export declare class ExploreMaterializer extends FluentState<Explore> {
+    /**
+     * Load a query contained within this loaded explore.
+     *
+     * @param name The name of the query to load.
+     * @returns A `QueryMaterializer` capable of materializing the requested query, running it,
+     * or loading further related objects.
+     */
+    loadQueryByName(name: string): QueryMaterializer;
+    /**
+     * Materialize a query contained within this loaded explore.
+     *
+     * @param name The name of the query to materialize.
+     * @returns A promise to the requested prepared query.
+     */
+    getQueryByName(name: string): Promise<PreparedQuery>;
+    /**
+     * Materialize this loaded explore.
+     *
+     * @returns A promise to the compiled `Explore`.
+     */
+    getExplore(): Promise<Explore>;
+}
+export declare type ResultJSON = {
+    queryResult: QueryResult;
+    modelDef: ModelDef;
+};
+/**
+ * The result of running a Malloy query.
+ *
+ * A `Result` is a `PreparedResult` along with the data retrieved from running the query.
+ */
+export declare class Result extends PreparedResult {
+    protected inner: QueryResult;
+    constructor(queryResult: QueryResult, modelDef: ModelDef);
+    get _queryResult(): QueryResult;
+    /**
+     * @returns The result data.
+     */
+    get data(): DataArray;
+    get totalRows(): number;
+    toJSON(): ResultJSON;
+    static fromJSON({ queryResult, modelDef }: ResultJSON): Result;
+}
+export declare type DataColumn = DataArray | DataRecord | DataString | DataBoolean | DataNumber | DataDate | DataTimestamp | DataNull | DataBytes;
+export declare type DataArrayOrRecord = DataArray | DataRecord;
+declare abstract class Data<T> {
+    protected _field: Field | Explore;
+    constructor(field: Field | Explore);
+    get field(): Field | Explore;
+    abstract get value(): T;
+    isString(): this is DataString;
+    get string(): DataString;
+    isBoolean(): this is DataBoolean;
+    get boolean(): DataBoolean;
+    isNumber(): this is DataNumber;
+    get number(): DataNumber;
+    isTimestamp(): this is DataTimestamp;
+    get timestamp(): DataTimestamp;
+    isDate(): this is DataDate;
+    get date(): DataDate;
+    isNull(): this is DataNull;
+    isBytes(): this is DataBytes;
+    get bytes(): DataBytes;
+    isRecord(): this is DataRecord;
+    get record(): DataRecord;
+    isArray(): this is DataArray;
+    get array(): DataArray;
+    isArrayOrRecord(): DataArrayOrRecord;
+}
+declare class ScalarData<T> extends Data<T> {
+    protected _value: T;
+    protected _field: AtomicField;
+    constructor(value: T, field: AtomicField);
+    get value(): T;
+    get field(): AtomicField;
+}
+declare class DataString extends ScalarData<string> {
+    protected _field: StringField;
+    constructor(value: string, field: StringField);
+    get field(): StringField;
+}
+declare class DataBoolean extends ScalarData<boolean> {
+    protected _field: BooleanField;
+    constructor(value: boolean, field: BooleanField);
+    get field(): BooleanField;
+}
+declare class DataNumber extends ScalarData<number> {
+    protected _field: NumberField;
+    constructor(value: number, field: NumberField);
+    get field(): NumberField;
+}
+declare class DataTimestamp extends ScalarData<Date> {
+    protected _field: TimestampField;
+    constructor(value: Date, field: TimestampField);
+    get value(): Date;
+    get field(): TimestampField;
+}
+declare class DataDate extends ScalarData<Date> {
+    protected _field: DateField;
+    constructor(value: Date, field: DateField);
+    get value(): Date;
+    get field(): DateField;
+}
+declare class DataBytes extends ScalarData<Buffer> {
+}
+declare class DataNull extends Data<null> {
+    get value(): null;
+}
+export declare class DataArray extends Data<QueryData> implements Iterable<DataRecord> {
+    readonly parent: DataArrayOrRecord | undefined;
+    private queryData;
+    protected _field: Explore;
+    constructor(queryData: QueryData, field: Explore, parent: DataArrayOrRecord | undefined);
+    /**
+     * @returns The `Explore` that describes the structure of this data.
+     */
+    get field(): Explore;
+    /**
+     * @returns The raw object form of the data.
+     */
+    toObject(): QueryData;
+    path(...path: (number | string)[]): DataColumn;
+    row(index: number): DataRecord;
+    get rowCount(): number;
+    get value(): QueryData;
+    [Symbol.iterator](): Iterator<DataRecord>;
+    inMemoryStream(): AsyncIterableIterator<DataRecord>;
+}
+export declare class DataRecord extends Data<{
+    [fieldName: string]: DataColumn;
+}> {
+    readonly parent: DataArrayOrRecord | undefined;
+    private queryDataRow;
+    protected _field: Explore;
+    readonly index: number | undefined;
+    constructor(queryDataRow: QueryDataRow, index: number | undefined, field: Explore, parent: DataArrayOrRecord | undefined);
+    toObject(): QueryDataRow;
+    path(...path: (number | string)[]): DataColumn;
+    cell(fieldOrName: string | Field): DataColumn;
+    get value(): {
+        [fieldName: string]: DataColumn;
+    };
+    get field(): Explore;
+    [Symbol.iterator](): Iterator<DataRecord>;
+}
+export interface WriteStream {
+    write: (text: string) => void;
+    close: () => void;
+}
+export declare abstract class DataWriter {
+    protected readonly stream: WriteStream;
+    constructor(stream: WriteStream);
+    abstract process(data: AsyncIterableIterator<DataRecord>): Promise<void>;
+}
+export declare class JSONWriter extends DataWriter {
+    process(data: AsyncIterableIterator<DataRecord>): Promise<void>;
+}
+export declare class CSVWriter extends DataWriter {
+    private readonly columnSeparator;
+    private readonly rowSeparator;
+    private readonly quoteCharacter;
+    private readonly includeHeader;
+    private escape;
+    private stringify;
+    process(data: AsyncIterableIterator<DataRecord>): Promise<void>;
+}
+export {};