@malloydata/malloy-query-builder 0.0.237-dev250225144145

package/dist/query-ast.js

@@ -0,0 +1,3633 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTAnnotation = exports.ASTAnnotationList = exports.ASTLimitViewOperation = exports.ASTView = exports.ASTFilterWithFilterString = exports.ASTFilter = exports.ASTWhereViewOperation = exports.ASTNestViewOperation = exports.ASTFilteredFieldExpression = exports.ASTWhereList = exports.ASTWhere = exports.ASTTimeTruncationExpression = exports.ASTReferenceExpression = exports.ASTExpression = exports.ASTField = exports.ASTAggregateViewOperation = exports.ASTGroupByViewOperation = exports.ASTOrderByViewOperation = exports.ASTViewOperation = exports.ASTViewOperationList = exports.ASTSegmentViewDefinition = exports.ASTRefinementViewDefinition = exports.ASTArrowViewDefinition = exports.ASTReferenceViewDefinition = exports.ASTReferenceQueryDefinition = exports.ASTRefinementQueryDefinition = exports.ASTArrowQueryDefinition = exports.ASTQueryDefinition = exports.ASTUnimplemented = exports.ASTTimestampLiteralValue = exports.ASTDateLiteralValue = exports.ASTBooleanLiteralValue = exports.ASTNumberLiteralValue = exports.ASTNullLiteralValue = exports.ASTStringLiteralValue = exports.LiteralValueAST = exports.ASTParameterValue = exports.ASTParameterValueList = exports.ASTSourceReference = exports.ASTFieldReference = exports.ASTReference = exports.ASTQuery = void 0;
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const Malloy = __importStar(require("@malloydata/malloy-interfaces"));
+const malloy_tag_1 = require("@malloydata/malloy-tag");
+const Filter = __importStar(require("@malloydata/malloy-filter"));
+class ASTNode {
+    constructor() {
+        /**
+         * @internal
+         */
+        this.edited = false;
+    }
+    /**
+     * @internal
+     */
+    edit() {
+        this.edited = true;
+        if (this._parent)
+            this._parent.edit();
+        return this;
+    }
+    /**
+     * Returns this node as an `ASTQuery`. Throws if it is not an `ASTQuery`.
+     *
+     * There are variants of this method for _all_ ASTXYZ nodes `asXYZ`, but they
+     * are not shown here so the docs aren't crazy big.
+     *
+     * @returns Returns this node as an `ASTQuery`.
+     */
+    asQuery() {
+        if (this instanceof ASTQuery)
+            return this;
+        throw new Error('Not an ASTQuery');
+    }
+    /**
+     * Finds the AST node at the given `path`. Throws if it is not an `ASTQuery`.
+     *
+     * There are variants of this method for _all_ ASTXYZ nodes `findXYZ`, but they
+     * are not shown here so the docs aren't crazy big.
+     *
+     * @param path Path to the desired ASTNode, e.g. `['source', 'parameters', 0]`
+     * @returns Returns this node as an `ASTQuery`.
+     */
+    findQuery(path) {
+        return this.find(path).asQuery();
+    }
+    /**
+     * @hidden
+     */
+    asReference() {
+        if (this instanceof ASTReference)
+            return this;
+        throw new Error('Not an ASTReference');
+    }
+    /**
+     * @hidden
+     */
+    findReference(path) {
+        return this.find(path).asReference();
+    }
+    /**
+     * @hidden
+     */
+    asSourceReference() {
+        if (this instanceof ASTSourceReference)
+            return this;
+        throw new Error('Not an ASTSourceReference');
+    }
+    /**
+     * @hidden
+     */
+    findSourceReference(path) {
+        return this.find(path).asSourceReference();
+    }
+    /**
+     * @hidden
+     */
+    asParameterValueList() {
+        if (this instanceof ASTParameterValueList)
+            return this;
+        throw new Error('Not an ASTParameterValueList');
+    }
+    /**
+     * @hidden
+     */
+    findParameterValueList(path) {
+        return this.find(path).asParameterValueList();
+    }
+    /**
+     * @hidden
+     */
+    asWhere() {
+        if (this instanceof ASTWhere)
+            return this;
+        throw new Error('Not an ASTWhere');
+    }
+    /**
+     * @hidden
+     */
+    findWhere(path) {
+        return this.find(path).asWhere();
+    }
+    /**
+     * @hidden
+     */
+    asWhereList() {
+        if (this instanceof ASTWhereList)
+            return this;
+        throw new Error('Not an ASTWhereList');
+    }
+    /**
+     * @hidden
+     */
+    findWhereList(path) {
+        return this.find(path).asWhereList();
+    }
+    /**
+     * @hidden
+     */
+    asParameterValue() {
+        if (this instanceof ASTParameterValue)
+            return this;
+        throw new Error('Not an ASTParameterValue');
+    }
+    /**
+     * @hidden
+     */
+    findParameterValue(path) {
+        return this.find(path).asParameterValue();
+    }
+    /**
+     * @hidden
+     */
+    asStringLiteralValue() {
+        if (this instanceof ASTStringLiteralValue)
+            return this;
+        throw new Error('Not an ASTStringLiteralValue');
+    }
+    /**
+     * @hidden
+     */
+    findStringLiteralValue(path) {
+        return this.find(path).asStringLiteralValue();
+    }
+    /**
+     * @hidden
+     */
+    asNumberLiteralValue() {
+        if (this instanceof ASTNumberLiteralValue)
+            return this;
+        throw new Error('Not an ASTNumberLiteralValue');
+    }
+    /**
+     * @hidden
+     */
+    findNumberLiteralValue(path) {
+        return this.find(path).asNumberLiteralValue();
+    }
+    /**
+     * @hidden
+     */
+    asViewOperationList() {
+        if (this instanceof ASTViewOperationList)
+            return this;
+        throw new Error('Not an ASTViewOperationList');
+    }
+    /**
+     * @hidden
+     */
+    findViewOperationList(path) {
+        return this.find(path).asViewOperationList();
+    }
+    /**
+     * @hidden
+     */
+    asGroupByViewOperation() {
+        if (this instanceof ASTGroupByViewOperation)
+            return this;
+        throw new Error('Not an ASTGroupByViewOperation');
+    }
+    /**
+     * @hidden
+     */
+    findGroupByViewOperation(path) {
+        return this.find(path).asGroupByViewOperation();
+    }
+    /**
+     * @hidden
+     */
+    asAggregateViewOperation() {
+        if (this instanceof ASTAggregateViewOperation)
+            return this;
+        throw new Error('Not an ASTAggregateViewOperation');
+    }
+    /**
+     * @hidden
+     */
+    findAggregateViewOperation(path) {
+        return this.find(path).asAggregateViewOperation();
+    }
+    /**
+     * @hidden
+     */
+    asOrderByViewOperation() {
+        if (this instanceof ASTOrderByViewOperation)
+            return this;
+        throw new Error('Not an ASTOrderByViewOperation');
+    }
+    /**
+     * @hidden
+     */
+    findOrderByViewOperation(path) {
+        return this.find(path).asOrderByViewOperation();
+    }
+    /**
+     * @hidden
+     */
+    asField() {
+        if (this instanceof ASTField)
+            return this;
+        throw new Error('Not an ASTField');
+    }
+    /**
+     * @hidden
+     */
+    findField(path) {
+        return this.find(path).asField();
+    }
+    /**
+     * @hidden
+     */
+    asReferenceExpression() {
+        if (this instanceof ASTReferenceExpression)
+            return this;
+        throw new Error('Not an ASTReferenceExpression');
+    }
+    /**
+     * @hidden
+     */
+    findReferenceExpression(path) {
+        return this.find(path).asReferenceExpression();
+    }
+    /**
+     * @hidden
+     */
+    asReferenceViewDefinition() {
+        if (this instanceof ASTReferenceViewDefinition)
+            return this;
+        throw new Error('Not an ASTReferenceViewDefinition');
+    }
+    /**
+     * @hidden
+     */
+    findReferenceViewDefinition(path) {
+        return this.find(path).asReferenceViewDefinition();
+    }
+    /**
+     * @hidden
+     */
+    asArrowQueryDefinition() {
+        if (this instanceof ASTArrowQueryDefinition)
+            return this;
+        throw new Error('Not an ASTArrowQueryDefinition');
+    }
+    /**
+     * @hidden
+     */
+    findArrowQueryDefinition(path) {
+        return this.find(path).asArrowQueryDefinition();
+    }
+    /**
+     * @hidden
+     */
+    asArrowViewDefinition() {
+        if (this instanceof ASTArrowViewDefinition)
+            return this;
+        throw new Error('Not an ASTArrowViewDefinition');
+    }
+    /**
+     * @hidden
+     */
+    findArrowViewDefinition(path) {
+        return this.find(path).asArrowViewDefinition();
+    }
+    /**
+     * @hidden
+     */
+    asRefinementViewDefinition() {
+        if (this instanceof ASTRefinementViewDefinition)
+            return this;
+        throw new Error('Not an ASTRefinementViewDefinition');
+    }
+    /**
+     * @hidden
+     */
+    findRefinementViewDefinition(path) {
+        return this.find(path).asRefinementViewDefinition();
+    }
+    /**
+     * @hidden
+     */
+    asTimeTruncationExpression() {
+        if (this instanceof ASTTimeTruncationExpression)
+            return this;
+        throw new Error('Not an ASTTimeTruncationExpression');
+    }
+    /**
+     * @hidden
+     */
+    findTimeTruncationExpression(path) {
+        return this.find(path).asTimeTruncationExpression();
+    }
+    /**
+     * @hidden
+     */
+    asFilteredFieldExpression() {
+        if (this instanceof ASTFilteredFieldExpression)
+            return this;
+        throw new Error('Not an ASTFilteredFieldExpression');
+    }
+    /**
+     * @hidden
+     */
+    findFilteredFieldExpression(path) {
+        return this.find(path).asFilteredFieldExpression();
+    }
+    /**
+     * @hidden
+     */
+    asNestViewOperation() {
+        if (this instanceof ASTNestViewOperation)
+            return this;
+        throw new Error('Not an ASTNestViewOperation');
+    }
+    /**
+     * @hidden
+     */
+    findNestViewOperation(path) {
+        return this.find(path).asNestViewOperation();
+    }
+    /**
+     * @hidden
+     */
+    asView() {
+        if (this instanceof ASTView)
+            return this;
+        throw new Error('Not an ASTView');
+    }
+    /**
+     * @hidden
+     */
+    findView(path) {
+        return this.find(path).asView();
+    }
+    /**
+     * @hidden
+     */
+    asSegmentViewDefinition() {
+        if (this instanceof ASTSegmentViewDefinition)
+            return this;
+        throw new Error('Not an ASTSegmentViewDefinition');
+    }
+    /**
+     * @hidden
+     */
+    findSegmentViewDefinition(path) {
+        return this.find(path).asSegmentViewDefinition();
+    }
+    /**
+     * @hidden
+     */
+    asLimitViewOperation() {
+        if (this instanceof ASTLimitViewOperation)
+            return this;
+        throw new Error('Not an ASTLimitViewOperation');
+    }
+    /**
+     * @hidden
+     */
+    findLimitViewOperation(path) {
+        return this.find(path).asLimitViewOperation();
+    }
+    /**
+     * @hidden
+     */
+    asAnnotationList() {
+        if (this instanceof ASTAnnotationList)
+            return this;
+        throw new Error('Not an ASTAnnotationList');
+    }
+    /**
+     * @hidden
+     */
+    findAnnotationList(path) {
+        return this.find(path).asAnnotationList();
+    }
+    /**
+     * @hidden
+     */
+    asAnnotation() {
+        if (this instanceof ASTAnnotation)
+            return this;
+        throw new Error('Not an ASTAnnotation');
+    }
+    /**
+     * @hidden
+     */
+    findAnnotation(path) {
+        return this.find(path).asAnnotation();
+    }
+    /**
+     * @internal
+     */
+    get parent() {
+        if (this._parent === undefined) {
+            throw new Error('This node does not have a parent');
+        }
+        return this._parent;
+    }
+    /**
+     * @internal
+     */
+    set parent(parent) {
+        this._parent = parent;
+    }
+    /**
+     * @internal
+     */
+    static schemaTryGet(schema, name, path) {
+        let current = schema;
+        for (const part of path !== null && path !== void 0 ? path : []) {
+            const field = current.fields.find(f => f.name === part);
+            if (field === undefined) {
+                throw new Error(`${part} not found`);
+            }
+            if (field.kind !== 'join') {
+                throw new Error(`${part} is not a join`);
+            }
+            current = field.schema;
+        }
+        const field = current.fields.find(f => f.name === name);
+        return field;
+    }
+    /**
+     * @internal
+     */
+    static schemaGet(schema, name, path) {
+        const field = ASTNode.schemaTryGet(schema, name, path);
+        if (field === undefined) {
+            throw new Error(`${name} not found`);
+        }
+        return field;
+    }
+    /**
+     * @internal
+     */
+    static schemaMerge(a, b) {
+        return {
+            fields: [...a.fields, ...b.fields],
+        };
+    }
+}
+function isBasic(t) {
+    return (Array.isArray(t) ||
+        typeof t === 'string' ||
+        typeof t === 'number' ||
+        typeof t === 'boolean');
+}
+class ASTListNode extends ASTNode {
+    constructor(node, children) {
+        super();
+        this.node = node;
+        this.children = children;
+        this.originalChildren = [...children];
+        children.forEach(c => (c.parent = this));
+    }
+    *iter() {
+        for (let i = 0; i < this.length; i++) {
+            yield this.index(i);
+        }
+    }
+    get length() {
+        return this.children.length;
+    }
+    get last() {
+        return this.children[this.children.length - 1];
+    }
+    /**
+     * Get the `i`th element of this list
+     *
+     * @param i The index of the list to get
+     * @returns The item at index `i` in this list
+     */
+    index(i) {
+        return this.children[i];
+    }
+    /**
+     * @internal
+     */
+    insert(n, index) {
+        this.edit();
+        this.children.splice(index, 0, n);
+        n.parent = this;
+    }
+    /**
+     * @internal
+     */
+    add(n) {
+        this.edit();
+        this.children.push(n);
+        n.parent = this;
+    }
+    /**
+     * @internal
+     */
+    remove(n) {
+        const idx = this.children.findIndex(o => o === n);
+        if (idx === -1)
+            return this;
+        this.edit();
+        this.children.splice(idx, 1);
+    }
+    /**
+     * @internal
+     */
+    build() {
+        if (!this.edited)
+            return this.node;
+        const ret = this.children.map(c => c.build());
+        this.edited = false;
+        this.originalChildren = [...this.children];
+        this.node = ret;
+        return ret;
+    }
+    /**
+     * @internal
+     */
+    find(path) {
+        if (path.length === 0) {
+            return this;
+        }
+        const [head, ...rest] = path;
+        if (typeof head !== 'number') {
+            throw new Error(`${this.constructor.name} is a ASTListNode and thus cannot contain a ${head}`);
+        }
+        const child = this.children[head];
+        return child.find(rest);
+    }
+    /**
+     * @internal
+     */
+    findIndex(predicate) {
+        return this.children.findIndex(predicate);
+    }
+    /**
+     * @internal
+     */
+    indexOf(n) {
+        return this.children.indexOf(n);
+    }
+}
+class ASTObjectNode extends ASTNode {
+    constructor(node, children) {
+        super();
+        this.node = node;
+        this.children = children;
+        for (const key in children) {
+            const child = children[key];
+            if (child && !isBasic(child)) {
+                child.parent = this;
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    build() {
+        if (!this.edited)
+            return this.node;
+        let ret = this.node;
+        for (const key in this.children) {
+            const child = this.children[key];
+            if (child === undefined) {
+                ret = { ...ret, [key]: undefined };
+            }
+            else if (isBasic(child)) {
+                if (this.edited) {
+                    ret = { ...ret, [key]: child };
+                }
+            }
+            else {
+                ret = { ...ret, [key]: child.build() };
+            }
+        }
+        this.node = ret;
+        this.edited = false;
+        return ret;
+    }
+    /**
+     * @internal
+     */
+    find(path) {
+        if (path.length === 0) {
+            return this;
+        }
+        const [head, ...rest] = path;
+        if (typeof head !== 'string') {
+            throw new Error(`${this.constructor.name} is a ASTListNode and thus cannot contain a ${head}`);
+        }
+        const child = this.children[head];
+        if (isBasic(child)) {
+            throw new Error(`${this.constructor.name}.${head} refers to a basic type, not an ASTNode`);
+        }
+        return child.find(rest);
+    }
+}
+/**
+ * AST Object to represent the whole query AST.
+ *
+ * ```ts
+ * const q = new ASTQuery({
+ *   source: flightsSourceInfo,
+ * });
+ * const segment = q.getOrAddDefaultSegment();
+ * segment.addGroupBy("carrier");
+ * segment.addOrderBy("carrier", Malloy.OrderByDirection.DESC);
+ * const malloy = q.toMalloy();
+ * const query = q.build();
+ * ```
+ */
+class ASTQuery extends ASTObjectNode {
+    constructor(options) {
+        var _a, _b;
+        let chosenSource = options.source;
+        if (chosenSource === undefined) {
+            if (options.model === undefined) {
+                throw new Error('Need a model or source');
+            }
+            if (options.query) {
+                const definition = options.query.definition;
+                if (definition.kind === 'arrow') {
+                    const name = definition.source_reference.name;
+                    chosenSource = options.model.entries.find(e => e.name === name);
+                    if (chosenSource === undefined) {
+                        throw new Error(`Model does not contain source or query named ${name}`);
+                    }
+                }
+            }
+            if (chosenSource === undefined) {
+                chosenSource = options.model.entries[0];
+            }
+            if (chosenSource === undefined) {
+                throw new Error('Model does not contain any sources or queries');
+            }
+        }
+        const source = sourceOrQueryToModelEntry(chosenSource);
+        const query = (_a = options.query) !== null && _a !== void 0 ? _a : {
+            definition: {
+                kind: 'arrow',
+                source_reference: {
+                    name: source.name,
+                },
+                view: {
+                    kind: 'segment',
+                    operations: [],
+                },
+            },
+        };
+        const model = (_b = options.model) !== null && _b !== void 0 ? _b : {
+            entries: [source],
+            anonymous_queries: [],
+        };
+        super(query, {
+            definition: exports.ASTQueryDefinition.from(query.definition),
+            annotations: query.annotations && new ASTAnnotationList(query.annotations),
+        });
+        this.model = model;
+        if (options.source) {
+            this.setSource(options.source.name);
+        }
+    }
+    get definition() {
+        return this.children.definition;
+    }
+    set definition(definition) {
+        this.edit();
+        this.children.definition = definition;
+        definition.parent = this;
+    }
+    get annotations() {
+        return this.children.annotations;
+    }
+    reorderFields(names) {
+        this.definition.reorderFields(names);
+    }
+    getOrAddAnnotations() {
+        if (this.annotations)
+            return this.annotations;
+        this.edit();
+        const annotations = new ASTAnnotationList([]);
+        this.children.annotations = annotations;
+        return annotations;
+    }
+    getInheritedTag(prefix = '# ') {
+        return tagFromAnnotations(prefix, this.getInheritedAnnotations());
+    }
+    getIntrinsicTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getIntrinsicTag(prefix)) !== null && _b !== void 0 ? _b : new malloy_tag_1.Tag();
+    }
+    getTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getTag(prefix)) !== null && _b !== void 0 ? _b : this.getInheritedTag(prefix);
+    }
+    setTagProperty(path, value = null, prefix = '# ') {
+        this.getOrAddAnnotations().setTagProperty(path, value, prefix);
+    }
+    removeTagProperty(path, prefix = '# ') {
+        if (!this.getTag().has(...path))
+            return;
+        this.getOrAddAnnotations().removeTagProperty(path, prefix);
+    }
+    setViewToEmptySegment() {
+        if (!(this.definition instanceof ASTArrowQueryDefinition)) {
+            throw new Error('Must set source before setting view');
+        }
+        this.definition = new ASTArrowQueryDefinition({
+            kind: 'arrow',
+            source_reference: this.definition.sourceReference.build(),
+            view: {
+                kind: 'segment',
+                operations: [],
+            },
+        });
+        return this.definition.view.asSegmentViewDefinition();
+    }
+    isRunnable() {
+        return this.definition.isRunnable();
+    }
+    /**
+     * Gets an {@link ASTSegmentViewDefinition} for the "default" place to add query
+     * operations, or creates one if it doesn't exist.
+     *
+     * ```
+     * run: flights ->
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment();
+     * ```
+     * ```
+     * run: flights -> { }
+     * ```
+     *
+     * If there is a view at the head, it will refine it:
+     * ```
+     * run: flights -> by_carrier
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment();
+     * ```
+     * ```
+     * run: flights -> by_carrier + { }
+     * ```
+     */
+    getOrAddDefaultSegment() {
+        return this.definition.getOrAddDefaultSegment();
+    }
+    /**
+     * Sets the source of this query to be a reference to a source in the model.
+     *
+     * ```ts
+     * q.setSource('flights')
+     * ```
+     * ```
+     * run: flights -> { }
+     * ```
+     *
+     * @param name The name of the source in the model to reference.
+     */
+    setSource(name) {
+        if (this.definition instanceof ASTArrowQueryDefinition) {
+            if (this.definition.sourceReference.name === name) {
+                return;
+            }
+        }
+        const source = this.model.entries.find(e => e.name === name);
+        if (source === undefined) {
+            throw new Error(`Source ${name} is not defined in model`);
+        }
+        this.definition = new ASTArrowQueryDefinition({
+            kind: 'arrow',
+            source_reference: { name },
+            view: this.definition instanceof ASTArrowQueryDefinition
+                ? this.definition.view.build()
+                : {
+                    kind: 'segment',
+                    operations: [],
+                },
+        });
+    }
+    /**
+     * Sets the head of this query to be a reference to a top level query.
+     *
+     * ```ts
+     * q.setQueryHead('flights_by_carrier')
+     * ```
+     * ```
+     * run: flights_by_carrier
+     * ```
+     *
+     * @param name The name of the query in the model to reference.
+     */
+    setQueryHead(name) {
+        const query = this.model.entries.find(e => e.name === name);
+        if (query === undefined || query.kind !== 'query') {
+            throw new Error(`No query named ${name} in the model`);
+        }
+        this.definition = new ASTReferenceQueryDefinition({
+            kind: 'query_reference',
+            name,
+        });
+    }
+    /**
+     * @internal
+     */
+    getQueryInfo(name) {
+        const query = this.model.entries.find(e => e.name === name);
+        if (query === undefined) {
+            throw new Error(`Query ${name} is not defined in model`);
+        }
+        if (query.kind !== 'query') {
+            throw new Error(`Model entry ${name} is not a query`);
+        }
+        return query;
+    }
+    /**
+     * Emits the current query object as Malloy code
+     *
+     * ```ts
+     * q.setSource('flights')
+     * q.setView('by_carrier')
+     * q.toMalloy();
+     * ```
+     * ```
+     * run: flights -> by_carrier
+     * ```
+     *
+     * @returns Malloy code for the query
+     */
+    toMalloy() {
+        return Malloy.queryToMalloy(this.build());
+    }
+    /**
+     * Build the query into its `Malloy.Query` object form. New JS objects will be
+     * created for any subtree which has edits.
+     *
+     * @returns A `Malloy.Query` representing the current query
+     */
+    build() {
+        return super.build();
+    }
+    /**
+     * Set the view of this query; overwrites any other query operations.
+     *
+     * ```
+     * run: flights ->
+     * ```
+     * ```ts
+     * q.setView('by_carrier')
+     * ```
+     * ```
+     * run: flights -> by_carrier
+     * ```
+     *
+     * @param name The name of the view to set as the head of the query pipeline
+     */
+    setView(name) {
+        if (!(this.definition instanceof ASTArrowQueryDefinition)) {
+            throw new Error('Must set source before setting view');
+        }
+        this.definition = new ASTArrowQueryDefinition({
+            kind: 'arrow',
+            source_reference: this.definition.sourceReference.build(),
+            view: {
+                kind: 'view_reference',
+                name,
+            },
+        });
+        return this.definition.view.asReferenceViewDefinition();
+    }
+    getInheritedAnnotations() {
+        var _a, _b;
+        if (this.definition instanceof ASTReferenceQueryDefinition) {
+            const query = this.getQueryInfo(this.definition.name);
+            return (_a = query.annotations) !== null && _a !== void 0 ? _a : [];
+        }
+        else if (this.definition instanceof ASTRefinementQueryDefinition) {
+            const query = this.getQueryInfo(this.definition.queryReference.name);
+            return (_b = query.annotations) !== null && _b !== void 0 ? _b : [];
+        }
+        else if (this.definition instanceof ASTArrowQueryDefinition) {
+            return this.definition.view.getInheritedAnnotations();
+        }
+        return [];
+    }
+}
+exports.ASTQuery = ASTQuery;
+class ASTReference extends ASTObjectNode {
+    constructor(reference) {
+        super(reference, {
+            name: reference.name,
+            path: reference.path,
+            parameters: reference.parameters && new ASTParameterValueList(reference.parameters),
+        });
+        this.reference = reference;
+    }
+    get name() {
+        return this.children.name;
+    }
+    set name(value) {
+        this.edit();
+        this.children.name = value;
+    }
+    get parameters() {
+        return this.children.parameters;
+    }
+    set parameters(parameters) {
+        this.edit();
+        this.children.parameters = parameters;
+    }
+    get path() {
+        return this.children.path;
+    }
+    /**
+     * @internal
+     */
+    static getOrAddParameters(reference) {
+        if (reference.parameters) {
+            return reference.parameters;
+        }
+        reference.edit();
+        const parameters = new ASTParameterValueList([]);
+        reference.parameters = parameters;
+        return parameters;
+    }
+    /**
+     * @internal
+     */
+    static setParameter(reference, name, value) {
+        return reference.getOrAddParameters().addParameter(name, value);
+    }
+    /**
+     * @internal
+     */
+    static tryGetParameter(reference, name) {
+        if (reference.parameters === undefined)
+            return undefined;
+        for (const parameter of reference.parameters.iter()) {
+            if (parameter.name === name) {
+                return parameter;
+            }
+        }
+    }
+    getOrAddParameters() {
+        return ASTReference.getOrAddParameters(this);
+    }
+    setParameter(name, value) {
+        return ASTReference.setParameter(this, name, value);
+    }
+    tryGetParameter(name) {
+        return ASTReference.tryGetParameter(this, name);
+    }
+}
+exports.ASTReference = ASTReference;
+class ASTFieldReference extends ASTReference {
+    /**
+     * @internal
+     */
+    get segment() {
+        const parent = this.parent;
+        if (parent instanceof ASTFilteredFieldExpression ||
+            parent instanceof ASTTimeTruncationExpression) {
+            return parent.field.segment;
+        }
+        else if (parent instanceof ASTFilterWithFilterString) {
+            const grand = parent.parent;
+            if (grand instanceof ASTWhere) {
+                return grand.list.expression.field.segment;
+            }
+            else {
+                return grand.list.segment;
+            }
+        }
+        else {
+            return parent.list.segment;
+        }
+    }
+    getFieldInfo() {
+        const schema = this.segment.getInputSchema();
+        return ASTNode.schemaGet(schema, this.name, this.path);
+    }
+}
+exports.ASTFieldReference = ASTFieldReference;
+class ASTSourceReference extends ASTReference {
+    /**
+     * @internal
+     */
+    get query() {
+        return this.parent.parent.asQuery();
+    }
+    /**
+     * Gets the `Malloy.SourceInfo` for the referenced source
+     *
+     * @returns The source information for the referenced source
+     */
+    getSourceInfo() {
+        const info = this.query.model.entries.find(e => e.name === this.name);
+        if (info === undefined) {
+            throw new Error('No source info found');
+        }
+        return info;
+    }
+    getSourceParameters() {
+        var _a;
+        return (_a = this.getSourceInfo().parameters) !== null && _a !== void 0 ? _a : [];
+    }
+    areRequiredParametersSet() {
+        const sourceParameters = this.getSourceParameters();
+        for (const parameterInfo of sourceParameters) {
+            if (parameterInfo.default_value !== undefined)
+                continue;
+            const parameter = this.tryGetParameter(parameterInfo.name);
+            if (parameter === undefined) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.ASTSourceReference = ASTSourceReference;
+class ASTParameterValueList extends ASTListNode {
+    constructor(parameters) {
+        super(parameters, parameters.map(p => new ASTParameterValue(p)));
+    }
+    get parameters() {
+        return this.children;
+    }
+    addParameter(name, value) {
+        // TODO validate that the parameter is valid (name and type)
+        this.add(new ASTParameterValue({
+            name,
+            value: exports.LiteralValueAST.makeLiteral(value),
+        }));
+    }
+}
+exports.ASTParameterValueList = ASTParameterValueList;
+class ASTParameterValue extends ASTObjectNode {
+    constructor(parameter) {
+        super(parameter, {
+            name: parameter.name,
+            value: exports.LiteralValueAST.from(parameter.value),
+        });
+        this.parameter = parameter;
+    }
+    get name() {
+        return this.children.name;
+    }
+}
+exports.ASTParameterValue = ASTParameterValue;
+exports.LiteralValueAST = {
+    from(value) {
+        switch (value.kind) {
+            case 'string_literal':
+                return new ASTStringLiteralValue(value);
+            case 'number_literal':
+                return new ASTNumberLiteralValue(value);
+            case 'boolean_literal':
+                return new ASTBooleanLiteralValue(value);
+            case 'date_literal':
+                return new ASTDateLiteralValue(value);
+            case 'timestamp_literal':
+                return new ASTTimestampLiteralValue(value);
+            case 'null_literal':
+                return new ASTNullLiteralValue(value);
+        }
+    },
+    makeLiteral(value) {
+        if (typeof value === 'string') {
+            return {
+                kind: 'string_literal',
+                string_value: value,
+            };
+        }
+        else if (typeof value === 'boolean') {
+            return {
+                kind: 'boolean_literal',
+                boolean_value: value,
+            };
+        }
+        else if (typeof value === 'number') {
+            return {
+                kind: 'number_literal',
+                number_value: value,
+            };
+        }
+        else if (value === null) {
+            return {
+                kind: 'null_literal',
+            };
+        }
+        else if ('date' in value) {
+            const granularity = value.granularity;
+            const serialized = serializeDateAsLiteral(value.date);
+            if (isDateTimeframe(granularity)) {
+                return {
+                    kind: 'date_literal',
+                    date_value: serialized,
+                    granularity: granularity,
+                };
+            }
+            return {
+                kind: 'timestamp_literal',
+                timestamp_value: serialized,
+                granularity: granularity,
+            };
+        }
+        throw new Error('Unknown literal type');
+    },
+};
+class ASTStringLiteralValue extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            string_value: node.string_value,
+        });
+        this.node = node;
+        this.kind = 'string_literal';
+    }
+}
+exports.ASTStringLiteralValue = ASTStringLiteralValue;
+class ASTNullLiteralValue extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+        });
+        this.node = node;
+        this.kind = 'null_literal';
+    }
+}
+exports.ASTNullLiteralValue = ASTNullLiteralValue;
+class ASTNumberLiteralValue extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            number_value: node.number_value,
+        });
+        this.node = node;
+        this.kind = 'number_literal';
+    }
+}
+exports.ASTNumberLiteralValue = ASTNumberLiteralValue;
+class ASTBooleanLiteralValue extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            boolean_value: node.boolean_value,
+        });
+        this.node = node;
+        this.kind = 'boolean_literal';
+    }
+}
+exports.ASTBooleanLiteralValue = ASTBooleanLiteralValue;
+class ASTDateLiteralValue extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            date_value: node.date_value,
+            granularity: node.granularity,
+        });
+        this.node = node;
+        this.kind = 'date_literal';
+    }
+}
+exports.ASTDateLiteralValue = ASTDateLiteralValue;
+class ASTTimestampLiteralValue extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            timestamp_value: node.timestamp_value,
+            granularity: node.granularity,
+        });
+        this.node = node;
+        this.kind = 'timestamp_literal';
+    }
+}
+exports.ASTTimestampLiteralValue = ASTTimestampLiteralValue;
+class ASTUnimplemented extends ASTNode {
+    constructor(node) {
+        super();
+        this.node = node;
+    }
+    get treeEdited() {
+        return false;
+    }
+    build() {
+        return this.node;
+    }
+    find() {
+        throw new Error('Tried to find a node from an unimplemented node type');
+    }
+}
+exports.ASTUnimplemented = ASTUnimplemented;
+exports.ASTQueryDefinition = {
+    from: (definition) => {
+        switch (definition.kind) {
+            case 'arrow':
+                return new ASTArrowQueryDefinition(definition);
+            case 'query_reference':
+                return new ASTReferenceQueryDefinition(definition);
+            case 'refinement':
+                return new ASTRefinementQueryDefinition(definition);
+        }
+    },
+};
+class ASTArrowQueryDefinition extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'arrow',
+            source_reference: new ASTSourceReference(node.source_reference),
+            view: ASTViewDefinition.from(node.view),
+        });
+        this.node = node;
+    }
+    get view() {
+        return this.children.view;
+    }
+    set view(view) {
+        this.edit();
+        this.children.view = view;
+        view.parent = this;
+    }
+    get sourceReference() {
+        return this.children.source_reference;
+    }
+    getOrAddDefaultSegment() {
+        return this.view.getOrAddDefaultSegment();
+    }
+    getSourceInfo() {
+        return this.sourceReference.getSourceInfo();
+    }
+    getOutputSchema() {
+        return this.view.getRefinementSchema();
+    }
+    isRunnable() {
+        return (this.view.isRunnable() && this.sourceReference.areRequiredParametersSet());
+    }
+    /**
+     * @internal
+     */
+    get query() {
+        return this.parent.asQuery();
+    }
+    /**
+     * @internal
+     */
+    propagateUp(f) {
+        this.propagateDown(f);
+    }
+    /**
+     * @internal
+     */
+    propagateDown(f) {
+        f(this.view);
+        this.view.propagateDown(f);
+    }
+    reorderFields(names) {
+        if (this.view instanceof ASTSegmentViewDefinition) {
+            this.view.reorderFields(names);
+        }
+        else {
+            this.query.getOrAddAnnotations().setTagProperty(['field_order'], names);
+        }
+    }
+}
+exports.ASTArrowQueryDefinition = ASTArrowQueryDefinition;
+class ASTRefinementQueryDefinition extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'refinement',
+            query_reference: new ASTReference(node.query_reference),
+            refinement: ASTViewDefinition.from(node.refinement),
+        });
+        this.node = node;
+    }
+    get queryReference() {
+        return this.children.query_reference;
+    }
+    get refinement() {
+        return this.children.refinement;
+    }
+    set refinement(refinement) {
+        this.edit();
+        this.children.refinement = refinement;
+        refinement.parent = this;
+    }
+    isRunnable() {
+        return this.refinement.isRunnable();
+    }
+    /**
+     * @internal
+     */
+    get query() {
+        return this.parent.asQuery();
+    }
+    getOrAddDefaultSegment() {
+        return this.refinement.getOrAddDefaultSegment();
+    }
+    getOutputSchema() {
+        const model = this.query.model;
+        const query = model.entries.find(e => e.name === this.queryReference.name);
+        if (query === undefined) {
+            throw new Error(`Query not found with name ${this.queryReference.name}`);
+        }
+        const base = query.schema;
+        const refinement = this.refinement.getRefinementSchema();
+        return ASTQuery.schemaMerge(base, refinement);
+    }
+    /**
+     * @internal
+     */
+    propagateUp(f) {
+        this.propagateDown(f);
+    }
+    /**
+     * @internal
+     */
+    propagateDown(f) {
+        f(this.refinement);
+        this.refinement.propagateDown(f);
+    }
+    reorderFields(names) {
+        this.query.getOrAddAnnotations().setTagProperty(['field_order'], names);
+    }
+}
+exports.ASTRefinementQueryDefinition = ASTRefinementQueryDefinition;
+class ASTReferenceQueryDefinition extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'query_reference',
+            name: node.name,
+            path: node.path,
+            parameters: node.parameters && new ASTParameterValueList(node.parameters),
+        });
+        this.node = node;
+    }
+    isRunnable() {
+        return true;
+    }
+    get name() {
+        return this.children.name;
+    }
+    get query() {
+        return this.parent.asQuery();
+    }
+    get parameters() {
+        return this.children.parameters;
+    }
+    set parameters(parameters) {
+        this.edit();
+        this.children.parameters = parameters;
+    }
+    get path() {
+        return this.children.path;
+    }
+    getOrAddDefaultSegment() {
+        var _a;
+        const newQuery = new ASTRefinementQueryDefinition({
+            kind: 'refinement',
+            query_reference: {
+                name: this.name,
+                path: this.path,
+                parameters: (_a = this.parameters) === null || _a === void 0 ? void 0 : _a.build(),
+            },
+            refinement: {
+                kind: 'segment',
+                operations: [],
+            },
+        });
+        this.query.definition = newQuery;
+        return newQuery.refinement.asSegmentViewDefinition();
+    }
+    /**
+     * @internal
+     */
+    propagateUp(_f) {
+        return;
+    }
+    /**
+     * @internal
+     */
+    propagateDown(_f) {
+        return;
+    }
+    reorderFields(names) {
+        this.query.getOrAddAnnotations().setTagProperty(['field_order'], names);
+    }
+    getOrAddParameters() {
+        return ASTReference.getOrAddParameters(this);
+    }
+    setParameter(name, value) {
+        return ASTReference.setParameter(this, name, value);
+    }
+    tryGetParameter(name) {
+        return ASTReference.tryGetParameter(this, name);
+    }
+}
+exports.ASTReferenceQueryDefinition = ASTReferenceQueryDefinition;
+const ASTViewDefinition = {
+    from(definition) {
+        switch (definition.kind) {
+            case 'arrow':
+                return new ASTArrowViewDefinition(definition);
+            case 'view_reference':
+                return new ASTReferenceViewDefinition(definition);
+            case 'segment':
+                return new ASTSegmentViewDefinition(definition);
+            case 'refinement':
+                return new ASTRefinementViewDefinition(definition);
+        }
+    },
+};
+function swapViewInParent(node, view) {
+    const parent = node.parent;
+    if (parent instanceof ASTArrowQueryDefinition) {
+        parent.view = view;
+    }
+    else if (parent instanceof ASTRefinementQueryDefinition) {
+        parent.refinement = view;
+    }
+    else if (parent instanceof ASTView) {
+        parent.definition = view;
+    }
+    else if (parent instanceof ASTArrowViewDefinition) {
+        if (parent.source === node) {
+            parent.source = view;
+        }
+        else {
+            parent.view = view;
+        }
+    }
+    else {
+        if (parent.base === node) {
+            parent.base = view;
+        }
+        else {
+            parent.refinement = view;
+        }
+    }
+}
+function isValidViewRefinement(view, name, path = []) {
+    const schema = view.getInputSchema();
+    const field = ASTQuery.schemaGet(schema, name, path);
+    if (field === undefined) {
+        return { isValidViewRefinement: false, error: `${name} is not defined` };
+    }
+    else if (field.kind !== 'view') {
+        // TODO scalar refinements
+        return { isValidViewRefinement: false, error: `${name} is not a view` };
+    }
+    const prevOutput = view.getOutputSchema();
+    for (const refinementField of field.schema.fields) {
+        if (ASTQuery.schemaTryGet(prevOutput, refinementField.name, [])) {
+            return {
+                isValidViewRefinement: false,
+                error: `Cannot refine with ${name} because stage already has an output field named ${refinementField.name}`,
+            };
+        }
+    }
+    return { isValidViewRefinement: true };
+}
+class ASTReferenceViewDefinition extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'view_reference',
+            name: node.name,
+            path: node.path,
+            parameters: node.parameters && new ASTParameterValueList(node.parameters),
+        });
+        this.node = node;
+    }
+    isRunnable() {
+        return true;
+    }
+    get name() {
+        return this.children.name;
+    }
+    get path() {
+        return this.children.path;
+    }
+    get parameters() {
+        return this.children.parameters;
+    }
+    set parameters(parameters) {
+        this.edit();
+        this.children.parameters = parameters;
+    }
+    getOrAddDefaultSegment() {
+        return this.addEmptyRefinement();
+    }
+    addEmptyRefinement() {
+        const newView = ASTRefinementViewDefinition.segmentRefinementOf(this.build());
+        swapViewInParent(this, newView);
+        return newView.refinement.asSegmentViewDefinition();
+    }
+    addViewRefinement(name, path) {
+        const { error } = this.isValidViewRefinement(name, path);
+        if (error) {
+            throw new Error(error);
+        }
+        const newView = ASTRefinementViewDefinition.viewRefinementOf(this.build(), name, path);
+        swapViewInParent(this, newView);
+        return newView.refinement.asReferenceViewDefinition();
+    }
+    isValidViewRefinement(name, path) {
+        return isValidViewRefinement(this, name, path);
+    }
+    getInputSchema() {
+        return getInputSchemaFromViewParent(this.parent);
+    }
+    getOutputSchema() {
+        const parent = this.parent;
+        return parent.getOutputSchema();
+    }
+    getImplicitName() {
+        return this.name;
+    }
+    getViewInfo() {
+        const schema = this.getInputSchema();
+        const view = ASTNode.schemaGet(schema, this.name, this.path);
+        if (view.kind !== 'view') {
+            throw new Error('Not a view');
+        }
+        return view;
+    }
+    getRefinementSchema() {
+        const view = this.getViewInfo();
+        return view.schema;
+    }
+    /**
+     * @internal
+     */
+    propagateUp(f) {
+        this.parent.propagateUp(f);
+    }
+    /**
+     * @internal
+     */
+    propagateDown(_f) {
+        return;
+    }
+    getInheritedAnnotations() {
+        var _a;
+        const view = this.getViewInfo();
+        return (_a = view.annotations) !== null && _a !== void 0 ? _a : [];
+    }
+    getOrAddParameters() {
+        return ASTReference.getOrAddParameters(this);
+    }
+    setParameter(name, value) {
+        return ASTReference.setParameter(this, name, value);
+    }
+    tryGetParameter(name) {
+        return ASTReference.tryGetParameter(this, name);
+    }
+}
+exports.ASTReferenceViewDefinition = ASTReferenceViewDefinition;
+class ASTArrowViewDefinition extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'arrow',
+            source: ASTViewDefinition.from(node.source),
+            view: ASTViewDefinition.from(node.view),
+        });
+        this.node = node;
+    }
+    isRunnable() {
+        return this.source.isRunnable() && this.view.isRunnable();
+    }
+    get source() {
+        return this.children.source;
+    }
+    set source(source) {
+        this.edit();
+        this.children.source = source;
+    }
+    get view() {
+        return this.children.view;
+    }
+    set view(view) {
+        this.edit();
+        this.children.view = view;
+        view.parent = this;
+    }
+    getOrAddDefaultSegment() {
+        return this.view.getOrAddDefaultSegment();
+    }
+    addEmptyRefinement() {
+        return this.view.addEmptyRefinement();
+    }
+    addViewRefinement(name, path) {
+        return this.view.addViewRefinement(name, path);
+    }
+    getInputSchema() {
+        return this.source.getOutputSchema();
+    }
+    getOutputSchema() {
+        return this.view.getRefinementSchema();
+    }
+    getImplicitName() {
+        return this.view.getImplicitName();
+    }
+    getRefinementSchema() {
+        throw new Error('An arrow is not a valid refinement');
+    }
+    isValidViewRefinement(name, path) {
+        return isValidViewRefinement(this, name, path);
+    }
+    /**
+     * @internal
+     */
+    propagateUp(f) {
+        this.propagateDown(f);
+    }
+    /**
+     * @internal
+     */
+    propagateDown(f) {
+        f(this.view);
+        this.view.propagateDown(f);
+    }
+    getInheritedAnnotations() {
+        return [];
+    }
+}
+exports.ASTArrowViewDefinition = ASTArrowViewDefinition;
+class ASTRefinementViewDefinition extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'refinement',
+            base: ASTViewDefinition.from(node.base),
+            refinement: ASTViewDefinition.from(node.refinement),
+        });
+        this.node = node;
+    }
+    isRunnable() {
+        return this.base.isRunnable() && this.refinement.isRunnable();
+    }
+    get refinement() {
+        return this.children.refinement;
+    }
+    set refinement(refinement) {
+        this.edit();
+        this.children.refinement = refinement;
+        refinement.parent = this;
+    }
+    get base() {
+        return this.children.base;
+    }
+    set base(base) {
+        this.edit();
+        this.children.base = base;
+    }
+    getOrAddDefaultSegment() {
+        return this.refinement.getOrAddDefaultSegment();
+    }
+    addEmptyRefinement() {
+        return this.refinement.addEmptyRefinement();
+    }
+    addViewRefinement(name, path) {
+        return this.refinement.addViewRefinement(name, path);
+    }
+    getInputSchema() {
+        return getInputSchemaFromViewParent(this.parent);
+    }
+    getOutputSchema() {
+        const parent = this.parent;
+        return parent.getOutputSchema();
+    }
+    getRefinementSchema() {
+        return ASTNode.schemaMerge(this.base.getRefinementSchema(), this.refinement.getRefinementSchema());
+    }
+    getImplicitName() {
+        return this.base.getImplicitName();
+    }
+    isValidViewRefinement(name, path) {
+        return isValidViewRefinement(this, name, path);
+    }
+    /**
+     * @internal
+     */
+    propagateUp(f) {
+        this.parent.propagateUp(f);
+    }
+    /**
+     * @internal
+     */
+    propagateDown(f) {
+        f(this.base);
+        f(this.refinement);
+        this.base.propagateDown(f);
+        this.refinement.propagateDown(f);
+    }
+    getInheritedAnnotations() {
+        return this.base.getInheritedAnnotations();
+    }
+    /**
+     * @internal
+     */
+    static viewRefinementOf(view, name, path) {
+        return new ASTRefinementViewDefinition({
+            kind: 'refinement',
+            base: view,
+            refinement: {
+                kind: 'view_reference',
+                name,
+                path,
+            },
+        });
+    }
+    /**
+     * @internal
+     */
+    static segmentRefinementOf(view) {
+        return new ASTRefinementViewDefinition({
+            kind: 'refinement',
+            base: view,
+            refinement: {
+                kind: 'segment',
+                operations: [],
+            },
+        });
+    }
+}
+exports.ASTRefinementViewDefinition = ASTRefinementViewDefinition;
+class ASTSegmentViewDefinition extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'segment',
+            operations: new ASTViewOperationList(node.operations),
+        });
+        this.node = node;
+        this.DEFAULT_INSERTION_ORDER = [
+            'where',
+            'group_by',
+            'aggregate',
+            'nest',
+            'order_by',
+        ];
+    }
+    isRunnable() {
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTAggregateViewOperation ||
+                operation instanceof ASTGroupByViewOperation ||
+                operation instanceof ASTNestViewOperation) {
+                return true;
+            }
+        }
+        return false;
+    }
+    get operations() {
+        return this.children.operations;
+    }
+    /**
+     * @internal
+     */
+    renameOrderBys(oldName, newName) {
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTOrderByViewOperation) {
+                if (operation.name === oldName) {
+                    operation.setField(newName);
+                }
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    propagateUp(f) {
+        this.parent.propagateUp(f);
+    }
+    /**
+     * @internal
+     */
+    propagateDown(_f) {
+        return;
+    }
+    /**
+     * @internal
+     */
+    removeOrderBys(name) {
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTOrderByViewOperation) {
+                if (operation.name === name) {
+                    operation.delete();
+                }
+            }
+        }
+    }
+    reorderFields(names) {
+        const leadingOperations = [];
+        const trailingOperations = [];
+        const opsByName = {};
+        let seenAnyNamed = false;
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTAggregateViewOperation ||
+                operation instanceof ASTGroupByViewOperation ||
+                operation instanceof ASTNestViewOperation) {
+                if (names.includes(operation.name)) {
+                    opsByName[operation.name] = operation;
+                    seenAnyNamed = true;
+                    continue;
+                }
+            }
+            if (seenAnyNamed) {
+                trailingOperations.push(operation);
+            }
+            else {
+                leadingOperations.push(operation);
+            }
+        }
+        const middleOperations = [];
+        for (const name of names) {
+            const operation = opsByName[name];
+            if (operation === undefined) {
+                throw new Error(`No field named ${name}`);
+            }
+            middleOperations.push(operation);
+        }
+        const operations = [
+            ...leadingOperations,
+            ...middleOperations,
+            ...trailingOperations,
+        ];
+        this.operations.items = operations;
+    }
+    renameField(field, name) {
+        if (field.name === name)
+            return;
+        const output = this.getOutputSchema();
+        if (ASTNode.schemaTryGet(output, name, [])) {
+            throw new Error(`Output already has a field named ${name}`);
+        }
+        const oldName = field.name;
+        field.name = name;
+        this.propagateUp(v => {
+            if (v instanceof ASTSegmentViewDefinition) {
+                v.renameOrderBys(oldName, name);
+            }
+        });
+    }
+    /**
+     * Adds an order by to the segment. Will override the direction of an existing order by
+     * if one is present for the same field.
+     *
+     * ```
+     * run: flights -> { group_by: carrier }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().addOrderBy("carrier", Malloy.OrderByDirection.DESC);
+     * ```
+     * ```
+     * run: flights -> {
+     *   group_by: carrier
+     *   order_by: carrier desc
+     * }
+     * ```
+     *
+     * The order by item is added after an existing order by operation if one is present,
+     * or to a new order by operation at the end of the query.
+     *
+     * @param name The name of the field to order by.
+     * @param direction The order by direction (ascending or descending).
+     */
+    addOrderBy(name, direction) {
+        // Ensure output schema has a field with this name
+        const outputSchema = this.getOutputSchema();
+        try {
+            ASTNode.schemaGet(outputSchema, name, []);
+        }
+        catch {
+            throw new Error(`No such field ${name} in stage output`);
+        }
+        // first see if there is already an order by for this field
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTOrderByViewOperation) {
+                if (operation.name === name) {
+                    operation.direction = direction;
+                    return;
+                }
+            }
+        }
+        // add a new order by operation
+        this.addOperation(new ASTOrderByViewOperation({
+            kind: 'order_by',
+            field_reference: { name },
+            direction,
+        }));
+    }
+    /**
+     * Adds an empty nest to this segment, with the given name.
+     * @param name The name of the new nest.
+     *
+     * The new nest is always added to the end of the query in a new nest block.
+     *
+     * ```
+     * run: flights -> { group_by: carrier }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().addEmptyNest("by_origin");
+     * ```
+     * ```
+     * run: flights -> {
+     *   group_by: carrier
+     *   nest: by_origin is { }
+     * }
+     * ```
+     *
+     * @returns The {@link ASTNestViewOperation} that was created.
+     *
+     */
+    addEmptyNest(name) {
+        const nest = new ASTNestViewOperation({
+            kind: 'nest',
+            name,
+            view: {
+                definition: {
+                    kind: 'segment',
+                    operations: [],
+                },
+            },
+        });
+        this.addOperation(nest);
+        return nest;
+    }
+    firstIndexOfOperationType(type) {
+        return this.operations.findIndex(o => o.kind === type);
+    }
+    findInsertionPoint(kind) {
+        const firstOfType = this.firstIndexOfOperationType(kind);
+        if (firstOfType > -1) {
+            let i = firstOfType;
+            while (this.operations.index(i) && this.operations.index(i).kind === kind)
+                i++;
+            return i;
+        }
+        const indexInOrder = this.DEFAULT_INSERTION_ORDER.indexOf(kind);
+        if (indexInOrder === -1) {
+            throw new Error(`Operation ${kind} is not supported for \`findInsertionPoint\``);
+        }
+        const laterOperations = this.DEFAULT_INSERTION_ORDER.slice(indexInOrder + 1);
+        for (const laterType of laterOperations) {
+            const firstOfType = this.firstIndexOfOperationType(laterType);
+            return firstOfType;
+        }
+        return this.operations.length;
+    }
+    getFieldNamed(name) {
+        const field = this.tryGetFieldNamed(name);
+        if (field === undefined)
+            throw new Error('No such field');
+        return field;
+    }
+    hasFieldNamed(name) {
+        return this.tryGetFieldNamed(name) !== undefined;
+    }
+    hasField(name, path) {
+        return this.tryGetField(name, path) !== undefined;
+    }
+    getField(name, path) {
+        const field = this.tryGetField(name, path);
+        if (field === undefined) {
+            throw new Error('No such field');
+        }
+        return field;
+    }
+    // TODO what constitutes "having a field" -- does "dep_time.month" count as dep_time?
+    // does flight_count {where: carrier = 'CA' } count as flight_count?
+    tryGetField(name, path) {
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTGroupByViewOperation ||
+                operation instanceof ASTAggregateViewOperation) {
+                const reference = operation.field.getReference();
+                if (reference.name === name && pathsMatch(reference.path, path)) {
+                    return operation;
+                }
+            }
+            else if (operation instanceof ASTNestViewOperation) {
+                if (operation.view instanceof ASTReferenceViewDefinition) {
+                    return operation;
+                }
+            }
+        }
+        return undefined;
+    }
+    tryGetFieldNamed(name) {
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTGroupByViewOperation ||
+                operation instanceof ASTAggregateViewOperation ||
+                operation instanceof ASTNestViewOperation) {
+                if (operation.name === name) {
+                    return operation;
+                }
+            }
+        }
+        return undefined;
+    }
+    getGroupBy(name) {
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTGroupByViewOperation) {
+                if (operation.name === name) {
+                    return operation;
+                }
+            }
+        }
+    }
+    removeGroupBy(name) {
+        var _a;
+        (_a = this.getGroupBy(name)) === null || _a === void 0 ? void 0 : _a.delete();
+        return this;
+    }
+    /**
+     * Adds a group by field with the given name to this segment.
+     *
+     * ```
+     * run: flights -> { }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().addGroupBy("carrier");
+     * ```
+     * ```
+     * run: flights -> { group_by: carrier }
+     * ```
+     *
+     * If there is already a group by clause, the new field will be added
+     * to that clause (or the first one if there are multiple).
+     *
+     * ```
+     * run: flights -> { group_by: carrier }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().addGroupBy("origin_code");
+     * ```
+     * ```
+     * run: flights -> {
+     *   group_by:
+     *     carrier
+     *     origin_code
+     * }
+     * ```
+     *
+     * If there is no group by clause, it will be added
+     *   1) before the first aggregate clause if there is one, or
+     *   2) before the first nest clause if there is one, or
+     *   3) before the first order by clause if ther is one, or
+     *   4) at the end of the query
+     *
+     * ```
+     * run: flights -> {
+     *   order_by: flight_count
+     *   aggregate: flight_count
+     * }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().addGroupBy("carrier");
+     * ```
+     * ```
+     * run: flights -> {
+     *   order_by: flight_count
+     *   group_by: carrier
+     *   aggregate: flight_count
+     * }
+     * ```
+     *
+     * @param name The name of the dimension to group by.
+     * @param path Join path for this dimension.
+     */
+    addGroupBy(name, path = [], rename) {
+        const item = this.makeField(name, path, rename, 'dimension');
+        this.addOperation(item);
+        return item;
+    }
+    addWhere(name, arg2, arg3) {
+        const path = Array.isArray(arg2) ? arg2 : [];
+        const filter = arg3 === undefined ? arg2 : arg3;
+        const filterString = typeof filter === 'string' ? filter : serializeFilter(filter);
+        const schema = this.getInputSchema();
+        // Validate name
+        const field = ASTQuery.schemaGet(schema, name, path);
+        // Validate filter
+        validateFilter(field, filter);
+        const item = new ASTWhereViewOperation({
+            kind: 'where',
+            filter: {
+                kind: 'filter_string',
+                field_reference: { name },
+                filter: filterString,
+            },
+        });
+        this.addOperation(item);
+        return item;
+    }
+    addTimeGroupBy(name, path, timeframe, type) {
+        const schema = this.getInputSchema();
+        const fieldInfo = ASTNode.schemaGet(schema, name, path);
+        if (fieldInfo === undefined) {
+            throw new Error(`No such field ${name}`);
+        }
+        if (fieldInfo.kind !== 'dimension') {
+            throw new Error(`Cannot group by non-dimension ${name}`);
+        }
+        if (fieldInfo.type.kind !== type) {
+            throw new Error(`${name} is not a ${type}`);
+        }
+        const item = new ASTGroupByViewOperation({
+            kind: 'group_by',
+            field: {
+                expression: {
+                    kind: 'time_truncation',
+                    field_reference: { name, path },
+                    truncation: timeframe,
+                },
+            },
+        });
+        this.addOperation(item);
+        return item;
+    }
+    addDateGroupBy(name, arg2, arg3) {
+        const timeframe = arg3 === undefined ? arg2 : arg3;
+        const path = arg3 === undefined ? [] : arg2;
+        return this.addTimeGroupBy(name, path, timeframe, 'date_type');
+    }
+    addTimestampGroupBy(name, arg2, arg3) {
+        const timeframe = arg3 === undefined ? arg2 : arg3;
+        const path = arg3 === undefined ? [] : arg2;
+        return this.addTimeGroupBy(name, path, timeframe, 'timestamp_type');
+    }
+    /**
+     * Adds an aggregate item with the given name to this segment.
+     *
+     * ```
+     * run: flights -> { }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().addAggregate("flight_count");
+     * ```
+     * ```
+     * run: flights -> { aggregate: flight_count }
+     * ```
+     *
+     * Added
+     *   1) at the end of an existing aggregate clause if ther is one, or
+     *   2) before the first nest clause if there is one, or
+     *   3) before the first order by clause if ther is one, or
+     *   4) at the end of the query
+     *
+     * @param name The name of the measure to aggregate.
+     * @param path The join path of the measure to aggregate.
+     * @param rename A new name for this measure
+     */
+    addAggregate(name, path = [], rename) {
+        const item = this.makeField(name, path, rename, 'measure');
+        this.addOperation(item);
+        return item;
+    }
+    /**
+     * Adds a nest item with the given name to this segment.
+     *
+     * ```
+     * run: flights -> { }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().addNest("by_carrier");
+     * ```
+     * ```
+     * run: flights -> { nest: by_carrier }
+     * ```
+     *
+     * Added
+     *   1) at the end of an existing nest clause if there is one, or
+     *   2) before the first order by clause if ther is one, or
+     *   3) at the end of the query
+     *
+     * @param name The name of the view to nest.
+     * @param rename A new name for this view in the query
+     */
+    addNest(name, rename) {
+        const item = this.makeField(name, [], rename, 'view');
+        this.addOperation(item);
+        return item;
+    }
+    makeField(name, path, rename, type) {
+        const schema = this.getInputSchema();
+        const fieldInfo = ASTNode.schemaGet(schema, name, path);
+        if (fieldInfo === undefined) {
+            throw new Error(`No such field ${name}`);
+        }
+        if (fieldInfo.kind !== type) {
+            const action = fieldTypeToAction(type);
+            const typeName = fieldTypeName(type);
+            throw new Error(`Cannot ${action} non-${typeName} ${name}`);
+        }
+        if (type === 'dimension') {
+            return ASTGroupByViewOperation.fromReference(name, path, rename);
+        }
+        else if (type === 'measure') {
+            return ASTAggregateViewOperation.fromReference(name, path, rename);
+        }
+        else {
+            return ASTNestViewOperation.fromReference(name, path, rename);
+        }
+    }
+    addOperation(item) {
+        if (item instanceof ASTGroupByViewOperation ||
+            item instanceof ASTAggregateViewOperation ||
+            item instanceof ASTNestViewOperation) {
+            if (this.hasFieldNamed(item.name)) {
+                throw new Error(`Query already has a field named ${item.name}`);
+            }
+        }
+        const whereToInsert = this.findInsertionPoint(item.kind);
+        this.operations.insert(item, whereToInsert);
+        return item;
+    }
+    /**
+     * @internal
+     */
+    getRefinementSchema() {
+        const fields = [];
+        for (const operation of this.operations.iter()) {
+            if (operation instanceof ASTGroupByViewOperation ||
+                operation instanceof ASTAggregateViewOperation ||
+                operation instanceof ASTNestViewOperation) {
+                // TODO convert measures into dimensions for output
+                fields.push(operation.getFieldInfo());
+            }
+        }
+        return { fields };
+    }
+    /**
+     * Sets the limit for this segment. Overrides an existing limit.
+     *
+     * ```
+     * run: flights -> { group_by: carrier }
+     * ```
+     * ```ts
+     * q.getOrAddDefaultSegment().setLimit(10);
+     * ```
+     * ```
+     * run: flights -> {
+     *   group_by: carrier
+     *   limit: 10
+     * }
+     * ```
+     *
+     * @param limit The limit to set. Must be an integer.
+     */
+    setLimit(limit) {
+        ASTLimitViewOperation.validateLimit(limit);
+        const limitOp = [
+            ...this.operations.iter(),
+        ].find(exports.ASTViewOperation.isLimit);
+        if (limitOp) {
+            limitOp.limit = limit;
+        }
+        else {
+            this.operations.add(new ASTLimitViewOperation({
+                kind: 'limit',
+                limit,
+            }));
+        }
+    }
+    getOrAddDefaultSegment() {
+        return this;
+    }
+    addEmptyRefinement() {
+        const view = ASTRefinementViewDefinition.segmentRefinementOf(this.build());
+        swapViewInParent(this, view);
+        return view.refinement.asSegmentViewDefinition();
+    }
+    addViewRefinement(name, path) {
+        const { error } = this.isValidViewRefinement(name, path);
+        if (error) {
+            throw new Error(error);
+        }
+        const view = ASTRefinementViewDefinition.viewRefinementOf(this.build(), name, path);
+        swapViewInParent(this, view);
+        return view.refinement.asReferenceViewDefinition();
+    }
+    getInputSchema() {
+        return getInputSchemaFromViewParent(this.parent);
+    }
+    getOutputSchema() {
+        const parent = this.parent;
+        return parent.getOutputSchema();
+    }
+    getImplicitName() {
+        return undefined;
+    }
+    isValidViewRefinement(name, path) {
+        return isValidViewRefinement(this, name, path);
+    }
+    getInheritedAnnotations() {
+        return [];
+    }
+}
+exports.ASTSegmentViewDefinition = ASTSegmentViewDefinition;
+class ASTViewOperationList extends ASTListNode {
+    constructor(operations) {
+        super(operations, operations.map(p => exports.ASTViewOperation.from(p)));
+    }
+    get items() {
+        return this.children;
+    }
+    /**
+     * @internal
+     */
+    set items(operations) {
+        this.edit();
+        this.children = operations;
+    }
+    /**
+     * @internal
+     */
+    get segment() {
+        return this.parent.asSegmentViewDefinition();
+    }
+}
+exports.ASTViewOperationList = ASTViewOperationList;
+exports.ASTViewOperation = {
+    from(value) {
+        switch (value.kind) {
+            case 'group_by':
+                return new ASTGroupByViewOperation(value);
+            case 'aggregate':
+                return new ASTAggregateViewOperation(value);
+            case 'order_by':
+                return new ASTOrderByViewOperation(value);
+            case 'nest':
+                return new ASTNestViewOperation(value);
+            case 'limit':
+                return new ASTLimitViewOperation(value);
+            case 'where':
+                return new ASTWhereViewOperation(value);
+        }
+    },
+    isLimit(x) {
+        return x instanceof ASTLimitViewOperation;
+    },
+};
+class ASTOrderByViewOperation extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'order_by',
+            field_reference: new ASTFieldReference(node.field_reference),
+            direction: node.direction,
+        });
+        this.node = node;
+        this.kind = 'order_by';
+    }
+    get fieldReference() {
+        return this.children.field_reference;
+    }
+    get name() {
+        return this.fieldReference.name;
+    }
+    get direction() {
+        return this.children.direction;
+    }
+    set direction(direction) {
+        if (this.direction === direction)
+            return;
+        this.edit();
+        this.children.direction = direction;
+    }
+    get list() {
+        return this.parent.asViewOperationList();
+    }
+    delete() {
+        const list = this.list;
+        list.remove(this);
+    }
+    setField(name) {
+        const schema = this.list.segment.getOutputSchema();
+        ASTNode.schemaGet(schema, name, []);
+        this.edit();
+        this.children.field_reference = new ASTFieldReference({ name });
+    }
+    setDirection(direction) {
+        this.direction = direction;
+    }
+}
+exports.ASTOrderByViewOperation = ASTOrderByViewOperation;
+class ASTGroupByViewOperation extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'group_by',
+            name: node.name,
+            field: new ASTField(node.field),
+        });
+        this.node = node;
+        this.kind = 'group_by';
+    }
+    get field() {
+        return this.children.field;
+    }
+    get name() {
+        var _a;
+        return (_a = this.children.name) !== null && _a !== void 0 ? _a : this.field.name;
+    }
+    set name(name) {
+        if (this.name === name)
+            return;
+        this.edit();
+        if (this.field.name === name) {
+            this.children.name = undefined;
+        }
+        else {
+            this.children.name = name;
+        }
+    }
+    /**
+     * @internal
+     */
+    get list() {
+        return this.parent.asViewOperationList();
+    }
+    /**
+     * Renames the group by item. If the field's name matches the given name,
+     * removes the `name is` part.
+     *
+     * ```
+     * run: flights -> { group_by: carrier }
+     * ```
+     * ```ts
+     * groupBy.rename("carrier_2");
+     * ```
+     * ```
+     * run: flights -> { group_by: carrier2 is carrier }
+     * ```
+     *
+     * ```
+     * run: flights -> { group_by: renamed is carrier }
+     * ```
+     * ```ts
+     * groupBy.rename("carrier");
+     * ```
+     * ```
+     * run: flights -> { group_by: carrier }
+     * ```
+     *
+     *
+     * @param name The new name
+     */
+    rename(name) {
+        this.list.segment.renameField(this, name);
+    }
+    /**
+     * Delete this group by item.
+     *
+     * Possible side effects:
+     *   - If this was the last item in the group by operation, the whole
+     *     operation is removed.
+     *   - Any order by that references this group by item will be removed.
+     *
+     * ```
+     * run: flights -> {
+     *   group_by: carrier
+     *   aggregate: flight_count
+     *   order by:
+     *     flight_count desc
+     *     carrier asc
+     * }
+     * ```
+     * ```ts
+     * groupBy.delete();
+     * ```
+     * ```
+     * run: flights -> {
+     *   aggregate: flight_count
+     *   order by: flight_count desc
+     * }
+     * ```
+     *
+     */
+    delete() {
+        this.list.remove(this);
+        this.list.segment.propagateUp(v => {
+            if (v instanceof ASTSegmentViewDefinition) {
+                v.removeOrderBys(this.name);
+            }
+        });
+    }
+    getFieldInfo() {
+        return {
+            kind: 'dimension',
+            name: this.name,
+            type: this.field.type,
+        };
+    }
+    get annotations() {
+        return this.field.annotations;
+    }
+    set annotations(annotations) {
+        this.edit();
+        this.field.annotations = annotations;
+    }
+    getOrAddAnnotations() {
+        return this.field.getOrAddAnnotations();
+    }
+    getInheritedTag(prefix = '# ') {
+        return tagFromAnnotations(prefix, this.field.getInheritedAnnotations());
+    }
+    getIntrinsicTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getIntrinsicTag(prefix)) !== null && _b !== void 0 ? _b : new malloy_tag_1.Tag();
+    }
+    getTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getTag(prefix)) !== null && _b !== void 0 ? _b : this.getInheritedTag(prefix);
+    }
+    setTagProperty(path, value = null, prefix = '# ') {
+        this.getOrAddAnnotations().setTagProperty(path, value, prefix);
+    }
+    removeTagProperty(path, prefix = '# ') {
+        if (!this.getTag().has(...path))
+            return;
+        this.getOrAddAnnotations().removeTagProperty(path, prefix);
+    }
+    /**
+     * @internal
+     */
+    static fromReference(name, path, rename) {
+        return new ASTGroupByViewOperation({
+            kind: 'group_by',
+            name: rename,
+            field: {
+                expression: {
+                    kind: 'field_reference',
+                    name,
+                    path,
+                },
+            },
+        });
+    }
+}
+exports.ASTGroupByViewOperation = ASTGroupByViewOperation;
+class ASTAggregateViewOperation extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'aggregate',
+            name: node.name,
+            field: new ASTField(node.field),
+        });
+        this.node = node;
+        this.kind = 'aggregate';
+    }
+    get field() {
+        return this.children.field;
+    }
+    get name() {
+        var _a;
+        return (_a = this.children.name) !== null && _a !== void 0 ? _a : this.field.name;
+    }
+    set name(name) {
+        if (this.name === name)
+            return;
+        this.edit();
+        if (this.field.name === name) {
+            this.children.name = undefined;
+        }
+        else {
+            this.children.name = name;
+        }
+    }
+    get annotations() {
+        return this.field.annotations;
+    }
+    /**
+     * Renames the aggregate item. If the field's name matches the given name,
+     * removes the `name is` part.
+     *
+     * ```
+     * run: flights -> { aggregate: flight_count }
+     * ```
+     * ```ts
+     * aggregate.rename("flight_count_2");
+     * ```
+     * ```
+     * run: flights -> { aggregate: flight_count2 is flight_count }
+     * ```
+     *
+     * ```
+     * run: flights -> { aggregate: renamed is flight_count }
+     * ```
+     * ```ts
+     * aggregate.rename("flight_count");
+     * ```
+     * ```
+     * run: flights -> { aggregate: flight_count }
+     * ```
+     *
+     *
+     * @param name The new name
+     */
+    rename(name) {
+        this.list.segment.renameField(this, name);
+    }
+    /**
+     * @internal
+     */
+    get list() {
+        return this.parent.asViewOperationList();
+    }
+    delete() {
+        this.list.remove(this);
+        this.list.segment.propagateUp(v => {
+            if (v instanceof ASTSegmentViewDefinition) {
+                v.removeOrderBys(this.name);
+            }
+        });
+    }
+    getFieldInfo() {
+        return {
+            kind: 'dimension',
+            name: this.name,
+            type: this.field.type,
+        };
+    }
+    getOrAddAnnotations() {
+        return this.field.getOrAddAnnotations();
+    }
+    getInheritedTag(prefix = '# ') {
+        return tagFromAnnotations(prefix, this.field.getInheritedAnnotations());
+    }
+    getIntrinsicTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getIntrinsicTag(prefix)) !== null && _b !== void 0 ? _b : new malloy_tag_1.Tag();
+    }
+    getTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getTag(prefix)) !== null && _b !== void 0 ? _b : this.getInheritedTag(prefix);
+    }
+    setTagProperty(path, value = null, prefix = '# ') {
+        this.getOrAddAnnotations().setTagProperty(path, value, prefix);
+    }
+    removeTagProperty(path, prefix = '# ') {
+        if (!this.getTag().has(...path))
+            return;
+        this.getOrAddAnnotations().removeTagProperty(path, prefix);
+    }
+    addWhere(name, arg2, arg3) {
+        const path = Array.isArray(arg2) ? arg2 : [];
+        const filter = arg3 === undefined ? arg2 : arg3;
+        const filterString = typeof filter === 'string' ? filter : serializeFilter(filter);
+        const schema = this.list.segment.getInputSchema();
+        const field = ASTQuery.schemaGet(schema, name, path);
+        // Validate filter
+        validateFilter(field, filter);
+        const where = {
+            filter: {
+                kind: 'filter_string',
+                field_reference: { name },
+                filter: filterString,
+            },
+        };
+        if (this.field.expression instanceof ASTFilteredFieldExpression) {
+            this.field.expression.where.add(new ASTWhere(where));
+            return this.field.expression;
+        }
+        else if (this.field.expression instanceof ASTReferenceExpression) {
+            const existing = this.field.expression.build();
+            this.field.expression = new ASTFilteredFieldExpression({
+                kind: 'filtered_field',
+                field_reference: {
+                    name: existing.name,
+                    path: existing.path,
+                    parameters: existing.parameters,
+                },
+                where: [where],
+            });
+            return this.field.expression;
+        }
+        else {
+            throw new Error('This kind of expression does not support addWhere');
+        }
+    }
+    /**
+     * @internal
+     */
+    static fromReference(name, path, rename) {
+        return new ASTAggregateViewOperation({
+            kind: 'aggregate',
+            name: rename,
+            field: {
+                expression: {
+                    kind: 'field_reference',
+                    name,
+                    path,
+                },
+            },
+        });
+    }
+}
+exports.ASTAggregateViewOperation = ASTAggregateViewOperation;
+class ASTField extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            expression: exports.ASTExpression.from(node.expression),
+            annotations: node.annotations && new ASTAnnotationList(node.annotations),
+        });
+        this.node = node;
+    }
+    get expression() {
+        return this.children.expression;
+    }
+    set expression(expression) {
+        this.edit();
+        this.children.expression = expression;
+        expression.parent = this;
+    }
+    get name() {
+        return this.expression.name;
+    }
+    get type() {
+        return this.expression.fieldType;
+    }
+    get annotations() {
+        return this.children.annotations;
+    }
+    set annotations(annotations) {
+        this.edit();
+        this.children.annotations = annotations;
+    }
+    // Returns a Malloy reference that this field points to
+    getReference() {
+        return this.expression.getReference();
+    }
+    getOrAddAnnotations() {
+        if (this.annotations)
+            return this.annotations;
+        this.edit();
+        const annotations = new ASTAnnotationList([]);
+        this.children.annotations = annotations;
+        return annotations;
+    }
+    getInheritedTag(prefix = '# ') {
+        return tagFromAnnotations(prefix, this.getInheritedAnnotations());
+    }
+    getIntrinsicTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getIntrinsicTag(prefix)) !== null && _b !== void 0 ? _b : new malloy_tag_1.Tag();
+    }
+    getTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getTag(prefix)) !== null && _b !== void 0 ? _b : this.getInheritedTag(prefix);
+    }
+    setTagProperty(path, value = null, prefix = '# ') {
+        this.getOrAddAnnotations().setTagProperty(path, value, prefix);
+    }
+    removeTagProperty(path, prefix = '# ') {
+        if (!this.getTag().has(...path))
+            return;
+        this.getOrAddAnnotations().removeTagProperty(path, prefix);
+    }
+    /**
+     * @internal
+     */
+    get segment() {
+        const groupByOrAggregate = this.parent;
+        const operationList = groupByOrAggregate.list;
+        return operationList.segment;
+    }
+    getInheritedAnnotations() {
+        return this.expression.getInheritedAnnotations();
+    }
+}
+exports.ASTField = ASTField;
+exports.ASTExpression = {
+    from(value) {
+        switch (value.kind) {
+            case 'field_reference':
+                return new ASTReferenceExpression(value);
+            case 'filtered_field':
+                return new ASTFilteredFieldExpression(value);
+            case 'time_truncation':
+                return new ASTTimeTruncationExpression(value);
+        }
+    },
+};
+// TODO would be nice for this to extend ASTFieldReference?
+class ASTReferenceExpression extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            name: node.name,
+            path: node.path,
+            parameters: node.parameters && new ASTParameterValueList(node.parameters),
+        });
+        this.node = node;
+        this.kind = 'field_reference';
+    }
+    get name() {
+        return this.children.name;
+    }
+    get parameters() {
+        return this.children.parameters;
+    }
+    set parameters(parameters) {
+        this.edit();
+        this.children.parameters = parameters;
+    }
+    /**
+     * @internal
+     */
+    get field() {
+        return this.parent.asField();
+    }
+    get path() {
+        return this.children.path;
+    }
+    getReference() {
+        return this.build();
+    }
+    getFieldInfo() {
+        const schema = this.field.segment.getInputSchema();
+        const def = ASTNode.schemaGet(schema, this.name, this.path);
+        if (def.kind !== 'dimension' && def.kind !== 'measure') {
+            throw new Error('Invalid field for ASTReferenceExpression');
+        }
+        return def;
+    }
+    get fieldType() {
+        return this.getFieldInfo().type;
+    }
+    getInheritedAnnotations() {
+        var _a;
+        const field = this.getFieldInfo();
+        return (_a = field.annotations) !== null && _a !== void 0 ? _a : [];
+    }
+    getOrAddParameters() {
+        return ASTReference.getOrAddParameters(this);
+    }
+    setParameter(name, value) {
+        return ASTReference.setParameter(this, name, value);
+    }
+    tryGetParameter(name) {
+        return ASTReference.tryGetParameter(this, name);
+    }
+}
+exports.ASTReferenceExpression = ASTReferenceExpression;
+class ASTTimeTruncationExpression extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            field_reference: new ASTFieldReference(node.field_reference),
+            truncation: node.truncation,
+        });
+        this.node = node;
+        this.kind = 'time_truncation';
+    }
+    getReference() {
+        return this.fieldReference.build();
+    }
+    get fieldReference() {
+        return this.children.field_reference;
+    }
+    get truncation() {
+        return this.children.truncation;
+    }
+    get name() {
+        return this.fieldReference.name;
+    }
+    /**
+     * @internal
+     */
+    get field() {
+        return this.parent.asField();
+    }
+    getFieldInfo() {
+        const schema = this.field.segment.getInputSchema();
+        const def = ASTNode.schemaGet(schema, this.name, this.fieldReference.path);
+        if (def.kind !== 'dimension' && def.kind !== 'measure') {
+            throw new Error('Invalid field for ASTReferenceExpression');
+        }
+        return def;
+    }
+    get fieldType() {
+        const def = this.getFieldInfo();
+        if (def.type.kind === 'date_type') {
+            return {
+                ...def.type,
+                timeframe: timestampTimeframeToDateTimeframe(this.truncation),
+            };
+        }
+        else if (def.type.kind === 'timestamp_type') {
+            return { ...def.type, timeframe: this.truncation };
+        }
+        throw new Error('This type of field cannot have a time truncation');
+    }
+    getInheritedAnnotations() {
+        var _a;
+        const field = this.getFieldInfo();
+        return (_a = field.annotations) !== null && _a !== void 0 ? _a : [];
+    }
+}
+exports.ASTTimeTruncationExpression = ASTTimeTruncationExpression;
+class ASTWhere extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            filter: exports.ASTFilter.from(node.filter),
+        });
+    }
+    get filter() {
+        return this.children.filter;
+    }
+    get list() {
+        return this.parent.asWhereList();
+    }
+    delete() {
+        this.list.remove(this);
+    }
+}
+exports.ASTWhere = ASTWhere;
+class ASTWhereList extends ASTListNode {
+    constructor(wheres) {
+        super(wheres, wheres.map(p => new ASTWhere(p)));
+    }
+    get expression() {
+        return this.parent.asFilteredFieldExpression();
+    }
+}
+exports.ASTWhereList = ASTWhereList;
+class ASTFilteredFieldExpression extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            field_reference: new ASTFieldReference(node.field_reference),
+            where: new ASTWhereList(node.where),
+        });
+        this.node = node;
+        this.kind = 'filtered_field';
+    }
+    getReference() {
+        return this.fieldReference.build();
+    }
+    get fieldReference() {
+        return this.children.field_reference;
+    }
+    get name() {
+        return this.fieldReference.name;
+    }
+    get where() {
+        return this.children.where;
+    }
+    /**
+     * @internal
+     */
+    get field() {
+        return this.parent.asField();
+    }
+    getFieldInfo() {
+        const schema = this.field.segment.getInputSchema();
+        const def = ASTNode.schemaGet(schema, this.name, this.fieldReference.path);
+        if (def.kind !== 'measure') {
+            throw new Error('Invalid field for ASTFilteredFieldExpression');
+        }
+        return def;
+    }
+    get fieldType() {
+        return this.getFieldInfo().type;
+    }
+    getInheritedAnnotations() {
+        var _a;
+        const field = this.getFieldInfo();
+        return (_a = field.annotations) !== null && _a !== void 0 ? _a : [];
+    }
+}
+exports.ASTFilteredFieldExpression = ASTFilteredFieldExpression;
+function timestampTimeframeToDateTimeframe(timeframe) {
+    switch (timeframe) {
+        case 'day':
+        case 'week':
+        case 'month':
+        case 'year':
+        case 'quarter':
+            return timeframe;
+        default:
+            throw new Error('Invalid date timeframe');
+    }
+}
+class ASTNestViewOperation extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'nest',
+            name: node.name,
+            view: new ASTView(node.view),
+        });
+        this.node = node;
+        this.kind = 'nest';
+    }
+    get view() {
+        return this.children.view;
+    }
+    get annotations() {
+        return this.view.annotations;
+    }
+    get name() {
+        var _a;
+        const name = (_a = this.children.name) !== null && _a !== void 0 ? _a : this.view.name;
+        if (name === undefined) {
+            throw new Error('Nest does not have a name');
+        }
+        return name;
+    }
+    set name(name) {
+        if (this.name === name)
+            return;
+        this.edit();
+        if (this.view.name === name) {
+            this.children.name = undefined;
+        }
+        else {
+            this.children.name = name;
+        }
+    }
+    /**
+     * @internal
+     */
+    get list() {
+        return this.parent.asViewOperationList();
+    }
+    getOrAddAnnotations() {
+        return this.view.getOrAddAnnotations();
+    }
+    getInheritedTag(prefix = '# ') {
+        return tagFromAnnotations(prefix, this.view.getInheritedAnnotations());
+    }
+    getIntrinsicTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getIntrinsicTag(prefix)) !== null && _b !== void 0 ? _b : new malloy_tag_1.Tag();
+    }
+    getTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getTag(prefix)) !== null && _b !== void 0 ? _b : this.getInheritedTag(prefix);
+    }
+    setTagProperty(path, value = null, prefix = '# ') {
+        this.getOrAddAnnotations().setTagProperty(path, value, prefix);
+    }
+    removeTagProperty(path, prefix = '# ') {
+        if (!this.getTag().has(...path))
+            return;
+        this.getOrAddAnnotations().removeTagProperty(path, prefix);
+    }
+    delete() {
+        this.list.remove(this);
+    }
+    /**
+     * Renames the nest item. If the view's name matches the given name,
+     * removes the `name is` part.
+     *
+     * ```
+     * run: flights -> { nest: by_carrier }
+     * ```
+     * ```ts
+     * nest.rename("by_carrier_2");
+     * ```
+     * ```
+     * run: flights -> { nest: by_carrier_2 is by_carrier }
+     * ```
+     *
+     * ```
+     * run: flights -> { nest: by_carrier_2 is by_carrier }
+     * ```
+     * ```ts
+     * nest.rename("by_carrier");
+     * ```
+     * ```
+     * run: flights -> { nest: by_carrier }
+     * ```
+     *
+     * ```
+     * run: flights -> {
+     *   nest: by_carrier is {
+     *     group_by: carrier
+     *   }
+     * }
+     * ```
+     * ```ts
+     * nest.rename("by_carrier_2");
+     * ```
+     * ```
+     * run: flights -> {
+     *   nest: by_carrier_2 is {
+     *     group_by: carrier
+     *   }
+     * }
+     * ```
+     *
+     * @param name The new name
+     */
+    rename(name) {
+        this.list.segment.renameField(this, name);
+    }
+    getFieldInfo() {
+        return {
+            kind: 'view',
+            name: this.name,
+            definition: this.view.build(),
+            schema: this.view.getOutputSchema(),
+        };
+    }
+    /**
+     * @internal
+     */
+    static fromReference(name, path, rename) {
+        return new ASTNestViewOperation({
+            kind: 'nest',
+            name: rename,
+            view: {
+                definition: {
+                    kind: 'view_reference',
+                    name,
+                    path,
+                },
+            },
+        });
+    }
+}
+exports.ASTNestViewOperation = ASTNestViewOperation;
+class ASTWhereViewOperation extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'where',
+            filter: exports.ASTFilter.from(node.filter),
+        });
+        this.node = node;
+        this.kind = 'nest';
+    }
+    get filter() {
+        return this.children.filter;
+    }
+    /**
+     * @internal
+     */
+    get list() {
+        return this.parent.asViewOperationList();
+    }
+    delete() {
+        this.list.remove(this);
+    }
+}
+exports.ASTWhereViewOperation = ASTWhereViewOperation;
+exports.ASTFilter = {
+    from(filter) {
+        return new ASTFilterWithFilterString(filter);
+    },
+};
+class ASTFilterWithFilterString extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            kind: 'filter_string',
+            field_reference: new ASTFieldReference(node.field_reference),
+            filter: node.filter,
+        });
+        this.node = node;
+        this.kind = 'filter_string';
+    }
+    get fieldReference() {
+        return this.children.field_reference;
+    }
+    get filterString() {
+        return this.children.filter;
+    }
+    set filterString(filter) {
+        this.edit();
+        this.children.filter = filter;
+    }
+    setFilterString(filterString) {
+        const kind = this.getFilterType();
+        parseFilter(this.filterString, kind);
+        this.filterString = filterString;
+    }
+    getFieldInfo() {
+        const field = this.fieldReference.getFieldInfo();
+        if (field.kind !== 'dimension' && field.kind !== 'measure') {
+            throw new Error('Invalid field type for filter with filter string');
+        }
+        return field;
+    }
+    getFilterType() {
+        const fieldInfo = this.getFieldInfo();
+        return getFilterType(fieldInfo);
+    }
+    setFilter(filter) {
+        const kind = this.getFilterType();
+        if (kind !== filter.kind) {
+            throw new Error(`Invalid filter: expected type ${kind}, got ${filter.kind}`);
+        }
+        this.filterString = serializeFilter(filter);
+    }
+    getFilter() {
+        const kind = this.getFilterType();
+        return parseFilter(this.filterString, kind);
+    }
+}
+exports.ASTFilterWithFilterString = ASTFilterWithFilterString;
+class ASTView extends ASTObjectNode {
+    constructor(node) {
+        super(node, {
+            definition: ASTViewDefinition.from(node.definition),
+            annotations: node.annotations && new ASTAnnotationList(node.annotations),
+        });
+        this.node = node;
+    }
+    get definition() {
+        return this.children.definition;
+    }
+    set definition(definition) {
+        this.edit();
+        this.children.definition = definition;
+        definition.parent = this;
+    }
+    get name() {
+        return this.definition.getImplicitName();
+    }
+    getOrAddDefaultSegment() {
+        return this.definition.getOrAddDefaultSegment();
+    }
+    /**
+     * @internal
+     */
+    get nest() {
+        return this.parent.asNestViewOperation();
+    }
+    getInputSchema() {
+        return this.nest.list.segment.getInputSchema();
+    }
+    getOutputSchema() {
+        return this.definition.getOutputSchema();
+    }
+    /**
+     * @internal
+     */
+    propagateUp(f) {
+        this.propagateDown(f);
+    }
+    /**
+     * @internal
+     */
+    propagateDown(f) {
+        f(this.definition);
+        this.definition.propagateDown(f);
+    }
+    reorderFields(names) {
+        if (this.definition instanceof ASTSegmentViewDefinition) {
+            this.definition.reorderFields(names);
+        }
+        else {
+            this.getOrAddAnnotations().setTagProperty(['field_order'], names);
+        }
+    }
+    get annotations() {
+        return this.children.annotations;
+    }
+    getOrAddAnnotations() {
+        if (this.annotations)
+            return this.annotations;
+        this.edit();
+        const annotations = new ASTAnnotationList([]);
+        this.children.annotations = annotations;
+        return annotations;
+    }
+    getInheritedAnnotations() {
+        return this.definition.getInheritedAnnotations();
+    }
+    getInheritedTag(prefix = '# ') {
+        return tagFromAnnotations(prefix, this.getInheritedAnnotations());
+    }
+    getIntrinsicTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getIntrinsicTag(prefix)) !== null && _b !== void 0 ? _b : new malloy_tag_1.Tag();
+    }
+    getTag(prefix = '# ') {
+        var _a, _b;
+        return (_b = (_a = this.annotations) === null || _a === void 0 ? void 0 : _a.getTag(prefix)) !== null && _b !== void 0 ? _b : this.getInheritedTag(prefix);
+    }
+    setTagProperty(path, value = null, prefix = '# ') {
+        this.getOrAddAnnotations().setTagProperty(path, value, prefix);
+    }
+    removeTagProperty(path, prefix = '# ') {
+        if (!this.getTag().has(...path))
+            return;
+        this.getOrAddAnnotations().removeTagProperty(path, prefix);
+    }
+}
+exports.ASTView = ASTView;
+class ASTLimitViewOperation extends ASTObjectNode {
+    get limit() {
+        return this.children.limit;
+    }
+    set limit(limit) {
+        ASTLimitViewOperation.validateLimit(limit);
+        this.edit();
+        this.children.limit = limit;
+    }
+    constructor(node) {
+        super(node, {
+            kind: node.kind,
+            limit: node.limit,
+        });
+        this.node = node;
+        this.kind = 'limit';
+    }
+    /**
+     * @internal
+     */
+    get list() {
+        return this.parent.asViewOperationList();
+    }
+    delete() {
+        this.list.remove(this);
+    }
+    /**
+     * @internal
+     */
+    static validateLimit(limit) {
+        if (!Number.isInteger(limit)) {
+            throw new Error('Limit must be an integer');
+        }
+    }
+}
+exports.ASTLimitViewOperation = ASTLimitViewOperation;
+function fieldTypeToAction(type) {
+    switch (type) {
+        case 'dimension':
+            return 'group by';
+        case 'measure':
+            return 'aggregate';
+        case 'view':
+            return 'nest';
+        case 'join':
+            return 'join';
+    }
+}
+function fieldTypeName(type) {
+    return type;
+}
+class ASTAnnotationList extends ASTListNode {
+    constructor(annotations) {
+        super(annotations, annotations.map(p => new ASTAnnotation(p)));
+    }
+    get items() {
+        return this.children;
+    }
+    getInheritedAnnotations() {
+        const parent = this.parent;
+        return parent.getInheritedAnnotations();
+    }
+    getIntrinsicTag(prefix = '# ') {
+        return tagFromAnnotations(prefix, this.items);
+    }
+    getTag(prefix = '# ') {
+        const extending = malloy_tag_1.Tag.fromTagLines(this.getInheritedAnnotations().map(a => a.value)).tag;
+        return tagFromAnnotations(prefix, this.items, extending);
+    }
+    get annotations() {
+        return this.children.map(astAnnotation => astAnnotation.node);
+    }
+    setTagProperty(path, value = null, prefix = '# ') {
+        let firstMatch = undefined;
+        for (let i = this.items.length - 1; i >= 0; i--) {
+            const annotation = this.index(i);
+            if (!annotation.hasPrefix(prefix))
+                continue;
+            firstMatch = annotation;
+            if (annotation.hasIntrinsicTagProperty(path)) {
+                annotation.setTagProperty(path, value);
+                return;
+            }
+        }
+        if (firstMatch) {
+            firstMatch.setTagProperty(path, value);
+        }
+        else {
+            this.add(new ASTAnnotation({
+                value: new malloy_tag_1.Tag({ prefix }).set(path, value).toString(),
+            }));
+        }
+    }
+    removeTagProperty(path, prefix = '# ') {
+        let firstMatch = undefined;
+        for (let i = this.items.length - 1; i >= 0; i--) {
+            const annotation = this.index(i);
+            if (!annotation.hasPrefix(prefix))
+                continue;
+            firstMatch = annotation;
+            if (annotation.hasIntrinsicTagProperty(path)) {
+                annotation.removeTagProperty(path);
+                return;
+            }
+        }
+        if (firstMatch) {
+            firstMatch.removeTagProperty(path);
+        }
+        else {
+            this.add(new ASTAnnotation({ value: new malloy_tag_1.Tag({ prefix }).unset(...path).toString() }));
+        }
+    }
+}
+exports.ASTAnnotationList = ASTAnnotationList;
+class ASTAnnotation extends ASTObjectNode {
+    get value() {
+        return this.children.value;
+    }
+    set value(value) {
+        this.edit();
+        this.children.value = value;
+    }
+    constructor(node) {
+        super(node, {
+            value: node.value,
+        });
+        this.node = node;
+        this.kind = 'limit';
+    }
+    /**
+     * @internal
+     */
+    get list() {
+        return this.parent.asAnnotationList();
+    }
+    get index() {
+        return this.list.indexOf(this);
+    }
+    delete() {
+        this.list.remove(this);
+    }
+    getIntrinsicTag() {
+        var _a;
+        return (_a = malloy_tag_1.Tag.fromTagLines([this.value]).tag) !== null && _a !== void 0 ? _a : new malloy_tag_1.Tag();
+    }
+    getTag() {
+        var _a, _b;
+        const extending = this.index === 0
+            ? (_a = malloy_tag_1.Tag.fromTagLines(this.list.getInheritedAnnotations().map(a => a.value)).tag) !== null && _a !== void 0 ? _a : new malloy_tag_1.Tag()
+            : this.list.index(this.index - 1).getTag();
+        return (_b = malloy_tag_1.Tag.fromTagLines([this.value], extending).tag) !== null && _b !== void 0 ? _b : new malloy_tag_1.Tag();
+    }
+    hasPrefix(prefix) {
+        return this.value.startsWith(prefix);
+    }
+    hasIntrinsicTagProperty(path) {
+        return this.getIntrinsicTag().has(...path);
+    }
+    setTagProperty(path, value) {
+        this.value = this.getTag().set(path, value).toString();
+    }
+    removeTagProperty(path) {
+        this.value = this.getTag()
+            .unset(...path)
+            .toString();
+    }
+}
+exports.ASTAnnotation = ASTAnnotation;
+function tagFromAnnotations(prefix, annotations = [], inherited) {
+    var _a;
+    const lines = annotations.map(a => a.value);
+    const filteredLines = lines.filter(l => typeof prefix === 'string' ? l.startsWith(prefix) : l.match(prefix));
+    return (_a = malloy_tag_1.Tag.fromTagLines(filteredLines, inherited).tag) !== null && _a !== void 0 ? _a : new malloy_tag_1.Tag();
+}
+function serializeFilter(filter) {
+    switch (filter.kind) {
+        case 'string':
+            return new Filter.StringSerializer(filter.clauses).serialize();
+        case 'number':
+            return new Filter.NumberSerializer(filter.clauses).serialize();
+        case 'boolean':
+            return new Filter.BooleanSerializer(filter.clauses).serialize();
+        case 'date':
+            return new Filter.DateSerializer(filter.clauses).serialize();
+    }
+}
+function parseFilter(filterString, kind) {
+    function handleError(logs) {
+        const errors = logs.filter(l => l.severity === 'error');
+        if (errors.length === 0)
+            return;
+        throw new Error(`Invalid Malloy filter string: ${errors[0].message}`);
+    }
+    switch (kind) {
+        case 'string': {
+            const result = new Filter.StringParser(filterString).parse();
+            handleError(result.logs);
+            return { kind, clauses: result.clauses };
+        }
+        case 'number': {
+            const result = new Filter.NumberParser(filterString).parse();
+            handleError(result.logs);
+            return { kind, clauses: result.clauses };
+        }
+        case 'boolean': {
+            const result = new Filter.BooleanParser(filterString).parse();
+            handleError(result.logs);
+            return { kind, clauses: result.clauses };
+        }
+        case 'date': {
+            const result = new Filter.DateParser(filterString).parse();
+            handleError(result.logs);
+            return { kind, clauses: result.clauses };
+        }
+        case 'other':
+            throw new Error('Not implemented');
+    }
+}
+function sourceOrQueryToModelEntry(entry) {
+    if ('kind' in entry) {
+        return entry;
+    }
+    else {
+        return { ...entry, kind: 'source' };
+    }
+}
+function isDateTimeframe(timeframe) {
+    switch (timeframe) {
+        case 'year':
+        case 'quarter':
+        case 'month':
+        case 'week':
+        case 'day':
+            return true;
+        default:
+            return false;
+    }
+}
+function digits(value, digits) {
+    return value.toString().padStart(digits, '0');
+}
+function serializeDateAsLiteral(date) {
+    const year = digits(date.getUTCFullYear(), 2);
+    const month = digits(date.getUTCMonth() + 1, 2);
+    const day = digits(date.getUTCDate(), 2);
+    const hour = digits(date.getUTCHours(), 2);
+    const minute = digits(date.getUTCMinutes(), 2);
+    const second = digits(date.getUTCSeconds(), 2);
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+}
+function pathsMatch(a, b) {
+    const aOrEmpty = a !== null && a !== void 0 ? a : [];
+    const bOrEmpty = b !== null && b !== void 0 ? b : [];
+    return (aOrEmpty.length === bOrEmpty.length &&
+        aOrEmpty.every((s, i) => s === bOrEmpty[i]));
+}
+function getFilterType(fieldInfo) {
+    switch (fieldInfo.type.kind) {
+        case 'string_type':
+            return 'string';
+        case 'boolean_type':
+            return 'boolean';
+        case 'number_type':
+            return 'number';
+        case 'date_type':
+        case 'timestamp_type':
+            return 'date';
+        default:
+            return 'other';
+    }
+}
+function validateFilter(field, filter) {
+    if (field.kind !== 'dimension' && field.kind !== 'measure') {
+        throw new Error(`Cannot filter by field of type ${field.kind}`);
+    }
+    const type = getFilterType(field);
+    if (typeof filter === 'string') {
+        parseFilter(filter, type);
+    }
+    else {
+        if (filter.kind !== type) {
+            throw new Error(`Invalid filter for field ${field.name}; expected type ${type}, but got ${filter.kind}`);
+        }
+    }
+}
+function getInputSchemaFromViewParent(parent) {
+    if (parent instanceof ASTArrowQueryDefinition) {
+        return parent.getSourceInfo().schema;
+    }
+    else if (parent instanceof ASTRefinementQueryDefinition) {
+        throw new Error('unimplemented');
+    }
+    else {
+        return parent.getInputSchema();
+    }
+}
+//# sourceMappingURL=query-ast.js.map