@malloydata/malloy-query-builder 0.0.237-dev250225144145

package/dist/query-ast.d.ts

@@ -0,0 +1,1614 @@
+import * as Malloy from '@malloydata/malloy-interfaces';
+import { Tag, TagSetValue } from '@malloydata/malloy-tag';
+import * as Filter from '@malloydata/malloy-filter';
+export type ParsedFilter = {
+    kind: 'string';
+    clauses: Filter.StringClause[];
+} | {
+    kind: 'number';
+    clauses: Filter.NumberClause[];
+} | {
+    kind: 'boolean';
+    clauses: Filter.BooleanClause[];
+} | {
+    kind: 'date';
+    clauses: Filter.DateClause[];
+};
+export type PathSegment = number | string;
+export type Path = PathSegment[];
+type ASTAny = ASTNode<unknown>;
+type ASTChildren<T> = {
+    [Key in keyof T]: LiteralOrNode<T[Key]>;
+};
+type NonOptionalASTNode<T> = T extends undefined ? never : ASTNode<T>;
+type LiteralOrNode<T> = T extends string ? T : T extends number ? T : T extends string[] ? T : T extends boolean ? T : undefined extends T ? NonOptionalASTNode<T> | undefined : ASTNode<T>;
+declare abstract class ASTNode<T> {
+    /**
+     * @internal
+     */
+    edited: boolean;
+    /**
+     * @internal
+     */
+    _parent: ASTAny | undefined;
+    abstract build(): T;
+    /**
+     * @internal
+     */
+    edit(): this;
+    /**
+     * @internal
+     */
+    abstract find(path: Path): ASTAny;
+    /**
+     * 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(): 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: Path): ASTQuery;
+    /**
+     * @hidden
+     */
+    asReference(): ASTReference;
+    /**
+     * @hidden
+     */
+    findReference(path: Path): ASTReference;
+    /**
+     * @hidden
+     */
+    asSourceReference(): ASTSourceReference;
+    /**
+     * @hidden
+     */
+    findSourceReference(path: Path): ASTSourceReference;
+    /**
+     * @hidden
+     */
+    asParameterValueList(): ASTParameterValueList;
+    /**
+     * @hidden
+     */
+    findParameterValueList(path: Path): ASTParameterValueList;
+    /**
+     * @hidden
+     */
+    asWhere(): ASTWhere;
+    /**
+     * @hidden
+     */
+    findWhere(path: Path): ASTWhere;
+    /**
+     * @hidden
+     */
+    asWhereList(): ASTWhereList;
+    /**
+     * @hidden
+     */
+    findWhereList(path: Path): ASTWhereList;
+    /**
+     * @hidden
+     */
+    asParameterValue(): ASTParameterValue;
+    /**
+     * @hidden
+     */
+    findParameterValue(path: Path): ASTParameterValue;
+    /**
+     * @hidden
+     */
+    asStringLiteralValue(): ASTStringLiteralValue;
+    /**
+     * @hidden
+     */
+    findStringLiteralValue(path: Path): ASTStringLiteralValue;
+    /**
+     * @hidden
+     */
+    asNumberLiteralValue(): ASTNumberLiteralValue;
+    /**
+     * @hidden
+     */
+    findNumberLiteralValue(path: Path): ASTNumberLiteralValue;
+    /**
+     * @hidden
+     */
+    asViewOperationList(): ASTViewOperationList;
+    /**
+     * @hidden
+     */
+    findViewOperationList(path: Path): ASTViewOperationList;
+    /**
+     * @hidden
+     */
+    asGroupByViewOperation(): ASTGroupByViewOperation;
+    /**
+     * @hidden
+     */
+    findGroupByViewOperation(path: Path): ASTGroupByViewOperation;
+    /**
+     * @hidden
+     */
+    asAggregateViewOperation(): ASTAggregateViewOperation;
+    /**
+     * @hidden
+     */
+    findAggregateViewOperation(path: Path): ASTAggregateViewOperation;
+    /**
+     * @hidden
+     */
+    asOrderByViewOperation(): ASTOrderByViewOperation;
+    /**
+     * @hidden
+     */
+    findOrderByViewOperation(path: Path): ASTOrderByViewOperation;
+    /**
+     * @hidden
+     */
+    asField(): ASTField;
+    /**
+     * @hidden
+     */
+    findField(path: Path): ASTField;
+    /**
+     * @hidden
+     */
+    asReferenceExpression(): ASTReferenceExpression;
+    /**
+     * @hidden
+     */
+    findReferenceExpression(path: Path): ASTReferenceExpression;
+    /**
+     * @hidden
+     */
+    asReferenceViewDefinition(): ASTReferenceViewDefinition;
+    /**
+     * @hidden
+     */
+    findReferenceViewDefinition(path: Path): ASTReferenceViewDefinition;
+    /**
+     * @hidden
+     */
+    asArrowQueryDefinition(): ASTArrowQueryDefinition;
+    /**
+     * @hidden
+     */
+    findArrowQueryDefinition(path: Path): ASTArrowQueryDefinition;
+    /**
+     * @hidden
+     */
+    asArrowViewDefinition(): ASTArrowViewDefinition;
+    /**
+     * @hidden
+     */
+    findArrowViewDefinition(path: Path): ASTArrowViewDefinition;
+    /**
+     * @hidden
+     */
+    asRefinementViewDefinition(): ASTRefinementViewDefinition;
+    /**
+     * @hidden
+     */
+    findRefinementViewDefinition(path: Path): ASTRefinementViewDefinition;
+    /**
+     * @hidden
+     */
+    asTimeTruncationExpression(): ASTTimeTruncationExpression;
+    /**
+     * @hidden
+     */
+    findTimeTruncationExpression(path: Path): ASTTimeTruncationExpression;
+    /**
+     * @hidden
+     */
+    asFilteredFieldExpression(): ASTFilteredFieldExpression;
+    /**
+     * @hidden
+     */
+    findFilteredFieldExpression(path: Path): ASTFilteredFieldExpression;
+    /**
+     * @hidden
+     */
+    asNestViewOperation(): ASTNestViewOperation;
+    /**
+     * @hidden
+     */
+    findNestViewOperation(path: Path): ASTNestViewOperation;
+    /**
+     * @hidden
+     */
+    asView(): ASTView;
+    /**
+     * @hidden
+     */
+    findView(path: Path): ASTView;
+    /**
+     * @hidden
+     */
+    asSegmentViewDefinition(): ASTSegmentViewDefinition;
+    /**
+     * @hidden
+     */
+    findSegmentViewDefinition(path: Path): ASTSegmentViewDefinition;
+    /**
+     * @hidden
+     */
+    asLimitViewOperation(): ASTLimitViewOperation;
+    /**
+     * @hidden
+     */
+    findLimitViewOperation(path: Path): ASTLimitViewOperation;
+    /**
+     * @hidden
+     */
+    asAnnotationList(): ASTAnnotationList;
+    /**
+     * @hidden
+     */
+    findAnnotationList(path: Path): ASTAnnotationList;
+    /**
+     * @hidden
+     */
+    asAnnotation(): ASTAnnotation;
+    /**
+     * @hidden
+     */
+    findAnnotation(path: Path): ASTAnnotation;
+    /**
+     * @internal
+     */
+    get parent(): ASTAny;
+    /**
+     * @internal
+     */
+    set parent(parent: ASTAny);
+    /**
+     * @internal
+     */
+    static schemaTryGet(schema: Malloy.Schema, name: string, path: string[] | undefined): Malloy.FieldInfo | undefined;
+    /**
+     * @internal
+     */
+    static schemaGet(schema: Malloy.Schema, name: string, path: string[] | undefined): Malloy.FieldInfo;
+    /**
+     * @internal
+     */
+    static schemaMerge(a: Malloy.Schema, b: Malloy.Schema): Malloy.Schema;
+}
+declare abstract class ASTListNode<T, N extends ASTNode<T> = ASTNode<T>> extends ASTNode<T[]> {
+    protected node: T[];
+    protected children: N[];
+    originalChildren: N[];
+    constructor(node: T[], children: N[]);
+    iter(): Generator<N, void, unknown>;
+    get length(): number;
+    get last(): N;
+    /**
+     * 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: number): N;
+    /**
+     * @internal
+     */
+    insert(n: N, index: number): void;
+    /**
+     * @internal
+     */
+    add(n: N): void;
+    /**
+     * @internal
+     */
+    remove(n: N): this | undefined;
+    /**
+     * @internal
+     */
+    build(): T[];
+    /**
+     * @internal
+     */
+    find(path: Path): ASTAny;
+    /**
+     * @internal
+     */
+    findIndex(predicate: (n: N) => boolean): number;
+    /**
+     * @internal
+     */
+    indexOf(n: N): number;
+}
+declare abstract class ASTObjectNode<T, Children extends ASTChildren<T>> extends ASTNode<T> {
+    protected node: T;
+    protected children: Children;
+    constructor(node: T, children: Children);
+    /**
+     * @internal
+     */
+    build(): T;
+    /**
+     * @internal
+     */
+    find(path: Path): ASTAny;
+}
+/**
+ * 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();
+ * ```
+ */
+export declare class ASTQuery extends ASTObjectNode<Malloy.Query, {
+    definition: ASTQueryDefinition;
+    annotations?: ASTAnnotationList;
+}> implements IASTAnnotatable {
+    model: Malloy.ModelInfo;
+    /**
+     * Create a new Query AST object against a given source.
+     *
+     * @param options.query Optional query to begin with; if none is provided, will
+     *                      use an empty query (`{pipeline: {stages: []}}`)
+     * @param options.source A source to base the query on. Will set the source name
+     *                       in the provided (or default) query to the name of this source.
+     */
+    constructor(options: {
+        query?: Malloy.Query;
+        source: Malloy.ModelEntryValueWithSource | Malloy.ModelEntryValueWithQuery | Malloy.SourceInfo | Malloy.QueryInfo;
+    });
+    /**
+     * Create a new Query AST object against a given model.
+     *
+     * @param options.query Optional query to begin with; if none is provided, will
+     *                      use an empty query (`{pipeline: {stages: []}}`)
+     * @param options.model A model to use for building this query. Use {@link setSource}
+     *                      to configure the source, or set {@link setQueryHead} to run
+     *                      a top level query in the model.
+     */
+    constructor(options: {
+        query?: Malloy.Query;
+        model: Malloy.ModelInfo;
+    });
+    get definition(): ASTQueryDefinition;
+    set definition(definition: ASTQueryDefinition);
+    get annotations(): ASTAnnotationList | undefined;
+    reorderFields(names: string[]): void;
+    getOrAddAnnotations(): ASTAnnotationList;
+    getInheritedTag(prefix?: RegExp | string): Tag;
+    getIntrinsicTag(prefix?: RegExp | string): Tag;
+    getTag(prefix?: RegExp | string): Tag;
+    setTagProperty(path: Path, value?: TagSetValue, prefix?: string): void;
+    removeTagProperty(path: Path, prefix?: string): void;
+    setViewToEmptySegment(): ASTSegmentViewDefinition;
+    isRunnable(): boolean;
+    /**
+     * 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(): ASTSegmentViewDefinition;
+    /**
+     * 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: string): void;
+    /**
+     * 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: string): void;
+    /**
+     * @internal
+     */
+    getQueryInfo(name: string): Malloy.QueryInfo;
+    /**
+     * 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(): string;
+    /**
+     * 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(): Malloy.Query;
+    /**
+     * 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: string): ASTReferenceViewDefinition;
+    getInheritedAnnotations(): Malloy.Annotation[];
+}
+export type RawLiteralValue = number | string | {
+    date: Date;
+    granularity: Malloy.TimestampTimeframe;
+} | boolean | null;
+export interface IASTReference extends ASTAny {
+    /**
+     * Gets the parameter list for this reference, or creates it if it does not exist.
+     *
+     * @returns The parameter list `ASTParameterValueList`
+     */
+    getOrAddParameters(): ASTParameterValueList;
+    /**
+     * Adds a parameter to this source with with the given name and value
+     *
+     * This will override an existing parameter with the same name.
+     *
+     * @param name The name of the parameter to set
+     * @param value The value of the parameter to set
+     */
+    setParameter(name: string, value: RawLiteralValue): void;
+    tryGetParameter(name: string): ASTParameterValue | undefined;
+    parameters: ASTParameterValueList | undefined;
+    name: string;
+    path: string[] | undefined;
+}
+export declare class ASTReference extends ASTObjectNode<Malloy.Reference, {
+    name: string;
+    path?: string[];
+    parameters?: ASTParameterValueList;
+}> implements IASTReference {
+    reference: Malloy.Reference;
+    constructor(reference: Malloy.Reference);
+    get name(): string;
+    set name(value: string);
+    get parameters(): ASTParameterValueList | undefined;
+    set parameters(parameters: ASTParameterValueList | undefined);
+    get path(): string[] | undefined;
+    /**
+     * @internal
+     */
+    static getOrAddParameters(reference: IASTReference): ASTParameterValueList;
+    /**
+     * @internal
+     */
+    static setParameter(reference: IASTReference, name: string, value: RawLiteralValue): void;
+    /**
+     * @internal
+     */
+    static tryGetParameter(reference: IASTReference, name: string): ASTParameterValue | undefined;
+    getOrAddParameters(): any;
+    setParameter(name: string, value: RawLiteralValue): void;
+    tryGetParameter(name: string): ASTParameterValue | undefined;
+}
+export declare class ASTFieldReference extends ASTReference {
+    /**
+     * @internal
+     */
+    get segment(): ASTSegmentViewDefinition;
+    getFieldInfo(): Malloy.FieldInfo;
+}
+export declare class ASTSourceReference extends ASTReference {
+    /**
+     * @internal
+     */
+    get query(): ASTQuery;
+    /**
+     * Gets the `Malloy.SourceInfo` for the referenced source
+     *
+     * @returns The source information for the referenced source
+     */
+    getSourceInfo(): Malloy.SourceInfo;
+    getSourceParameters(): Malloy.ParameterInfo[];
+    areRequiredParametersSet(): boolean;
+}
+export declare class ASTParameterValueList extends ASTListNode<Malloy.ParameterValue, ASTParameterValue> {
+    constructor(parameters: Malloy.ParameterValue[]);
+    get parameters(): ASTParameterValue[];
+    addParameter(name: string, value: RawLiteralValue): void;
+}
+export declare class ASTParameterValue extends ASTObjectNode<Malloy.ParameterValue, {
+    name: string;
+    value: ASTLiteralValue;
+}> {
+    parameter: Malloy.ParameterValue;
+    constructor(parameter: Malloy.ParameterValue);
+    get name(): string;
+}
+export type ASTLiteralValue = ASTStringLiteralValue | ASTNumberLiteralValue | ASTBooleanLiteralValue | ASTDateLiteralValue | ASTTimestampLiteralValue | ASTNullLiteralValue;
+export declare const LiteralValueAST: {
+    from(value: Malloy.LiteralValue): ASTStringLiteralValue | ASTNumberLiteralValue | ASTBooleanLiteralValue | ASTDateLiteralValue | ASTTimestampLiteralValue | ASTNullLiteralValue;
+    makeLiteral(value: RawLiteralValue): Malloy.LiteralValue;
+};
+export declare class ASTStringLiteralValue extends ASTObjectNode<Malloy.LiteralValueWithStringLiteral, {
+    kind: 'string_literal';
+    string_value: string;
+}> {
+    node: Malloy.LiteralValueWithStringLiteral;
+    readonly kind: Malloy.LiteralValueType;
+    constructor(node: Malloy.LiteralValueWithStringLiteral);
+}
+export declare class ASTNullLiteralValue extends ASTObjectNode<Malloy.LiteralValueWithNullLiteral, {
+    kind: 'null_literal';
+}> {
+    node: Malloy.LiteralValueWithNullLiteral;
+    readonly kind: Malloy.LiteralValueType;
+    constructor(node: Malloy.LiteralValueWithNullLiteral);
+}
+export declare class ASTNumberLiteralValue extends ASTObjectNode<Malloy.LiteralValueWithNumberLiteral, {
+    kind: 'number_literal';
+    number_value: number;
+}> {
+    node: Malloy.LiteralValueWithNumberLiteral;
+    readonly kind: Malloy.LiteralValueType;
+    constructor(node: Malloy.LiteralValueWithNumberLiteral);
+}
+export declare class ASTBooleanLiteralValue extends ASTObjectNode<Malloy.LiteralValueWithBooleanLiteral, {
+    kind: 'boolean_literal';
+    boolean_value: boolean;
+}> {
+    node: Malloy.LiteralValueWithBooleanLiteral;
+    readonly kind: Malloy.LiteralValueType;
+    constructor(node: Malloy.LiteralValueWithBooleanLiteral);
+}
+export declare class ASTDateLiteralValue extends ASTObjectNode<Malloy.LiteralValueWithDateLiteral, {
+    kind: 'date_literal';
+    date_value: string;
+    granularity?: Malloy.DateTimeframe;
+}> {
+    node: Malloy.LiteralValueWithDateLiteral;
+    readonly kind: Malloy.LiteralValueType;
+    constructor(node: Malloy.LiteralValueWithDateLiteral);
+}
+export declare class ASTTimestampLiteralValue extends ASTObjectNode<Malloy.LiteralValueWithTimestampLiteral, {
+    kind: 'timestamp_literal';
+    timestamp_value: string;
+    granularity?: Malloy.TimestampTimeframe;
+}> {
+    node: Malloy.LiteralValueWithTimestampLiteral;
+    readonly kind: Malloy.LiteralValueType;
+    constructor(node: Malloy.LiteralValueWithTimestampLiteral);
+}
+export declare class ASTUnimplemented<T> extends ASTNode<T> {
+    private readonly node;
+    constructor(node: T);
+    get treeEdited(): boolean;
+    build(): T;
+    find(): never;
+}
+export interface IASTQueryOrViewDefinition {
+    /**
+     * Upward propagation of field deletion/rename etc
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * Downward propagation of field deletion/rename etc
+     * @internal
+     */
+    propagateDown(f: PropagationFunction): void;
+}
+type PropagationFunction = (propagatable: IASTQueryOrViewDefinition) => void;
+export interface IASTQueryDefinition extends IASTQueryOrViewDefinition {
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    reorderFields(names: string[]): void;
+    isRunnable(): boolean;
+}
+export type ASTQueryDefinition = ASTReferenceQueryDefinition | ASTArrowQueryDefinition | ASTRefinementQueryDefinition;
+export declare const ASTQueryDefinition: {
+    from: (definition: Malloy.QueryDefinition) => ASTArrowQueryDefinition | ASTReferenceQueryDefinition | ASTRefinementQueryDefinition;
+};
+export declare class ASTArrowQueryDefinition extends ASTObjectNode<Malloy.QueryDefinitionWithArrow, {
+    kind: 'arrow';
+    source_reference: ASTSourceReference;
+    view: ASTViewDefinition;
+}> implements IASTQueryDefinition {
+    node: Malloy.QueryDefinitionWithArrow;
+    constructor(node: Malloy.QueryDefinitionWithArrow);
+    get view(): ASTViewDefinition;
+    set view(view: ASTViewDefinition);
+    get sourceReference(): ASTSourceReference;
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    getSourceInfo(): Malloy.SourceInfo;
+    getOutputSchema(): Malloy.Schema;
+    isRunnable(): boolean;
+    /**
+     * @internal
+     */
+    get query(): ASTQuery;
+    /**
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(f: PropagationFunction): void;
+    reorderFields(names: string[]): void;
+}
+export declare class ASTRefinementQueryDefinition extends ASTObjectNode<Malloy.QueryDefinitionWithRefinement, {
+    kind: 'refinement';
+    query_reference: ASTReference;
+    refinement: ASTViewDefinition;
+}> implements IASTQueryDefinition {
+    node: Malloy.QueryDefinitionWithRefinement;
+    constructor(node: Malloy.QueryDefinitionWithRefinement);
+    get queryReference(): ASTReference;
+    get refinement(): ASTViewDefinition;
+    set refinement(refinement: ASTViewDefinition);
+    isRunnable(): boolean;
+    /**
+     * @internal
+     */
+    get query(): ASTQuery;
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    getOutputSchema(): Malloy.Schema;
+    /**
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(f: PropagationFunction): void;
+    reorderFields(names: string[]): void;
+}
+export declare class ASTReferenceQueryDefinition extends ASTObjectNode<Malloy.QueryDefinitionWithQueryReference, {
+    kind: 'query_reference';
+    name: string;
+    path?: string[];
+    parameters?: ASTParameterValueList;
+}> implements IASTQueryDefinition, IASTReference {
+    node: Malloy.QueryDefinitionWithQueryReference;
+    constructor(node: Malloy.QueryDefinitionWithQueryReference);
+    isRunnable(): boolean;
+    get name(): string;
+    get query(): ASTQuery;
+    get parameters(): ASTParameterValueList | undefined;
+    set parameters(parameters: ASTParameterValueList | undefined);
+    get path(): string[] | undefined;
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    /**
+     * @internal
+     */
+    propagateUp(_f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(_f: PropagationFunction): void;
+    reorderFields(names: string[]): void;
+    getOrAddParameters(): any;
+    setParameter(name: string, value: RawLiteralValue): void;
+    tryGetParameter(name: string): ASTParameterValue | undefined;
+}
+export interface IASTViewDefinition extends IASTQueryOrViewDefinition {
+    isRunnable(): boolean;
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    getInputSchema(): Malloy.Schema;
+    getOutputSchema(): Malloy.Schema;
+    getImplicitName(): string | undefined;
+    getRefinementSchema(): Malloy.Schema;
+    addEmptyRefinement(): ASTSegmentViewDefinition;
+    addViewRefinement(name: string, path?: string[]): ASTReferenceViewDefinition;
+    isValidViewRefinement(name: string, path?: string[]): {
+        isValidViewRefinement: boolean;
+        error?: string;
+    };
+    getInheritedAnnotations(): Malloy.Annotation[];
+}
+export type ASTViewDefinition = ASTArrowViewDefinition | ASTRefinementViewDefinition | ASTSegmentViewDefinition | ASTReferenceViewDefinition;
+export declare class ASTReferenceViewDefinition extends ASTObjectNode<Malloy.ViewDefinitionWithViewReference, {
+    kind: 'view_reference';
+    name: string;
+    path?: string[];
+    parameters?: ASTParameterValueList;
+}> implements IASTViewDefinition, IASTReference {
+    node: Malloy.ViewDefinitionWithViewReference;
+    constructor(node: Malloy.ViewDefinitionWithViewReference);
+    isRunnable(): boolean;
+    get name(): string;
+    get path(): string[] | undefined;
+    get parameters(): ASTParameterValueList | undefined;
+    set parameters(parameters: ASTParameterValueList | undefined);
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    addEmptyRefinement(): ASTSegmentViewDefinition;
+    addViewRefinement(name: string, path?: string[]): ASTReferenceViewDefinition;
+    isValidViewRefinement(name: string, path?: string[]): {
+        isValidViewRefinement: boolean;
+        error?: string;
+    };
+    getInputSchema(): Malloy.Schema;
+    getOutputSchema(): Malloy.Schema;
+    getImplicitName(): string | undefined;
+    getViewInfo(): Malloy.FieldInfoWithView;
+    getRefinementSchema(): Malloy.Schema;
+    /**
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(_f: PropagationFunction): void;
+    getInheritedAnnotations(): Malloy.Annotation[];
+    getOrAddParameters(): any;
+    setParameter(name: string, value: RawLiteralValue): void;
+    tryGetParameter(name: string): ASTParameterValue | undefined;
+}
+export declare class ASTArrowViewDefinition extends ASTObjectNode<Malloy.ViewDefinitionWithArrow, {
+    kind: 'arrow';
+    source: ASTViewDefinition;
+    view: ASTViewDefinition;
+}> implements IASTViewDefinition {
+    node: Malloy.ViewDefinitionWithArrow;
+    constructor(node: Malloy.ViewDefinitionWithArrow);
+    isRunnable(): boolean;
+    get source(): ASTViewDefinition;
+    set source(source: ASTViewDefinition);
+    get view(): ASTViewDefinition;
+    set view(view: ASTViewDefinition);
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    addEmptyRefinement(): ASTSegmentViewDefinition;
+    addViewRefinement(name: string, path?: string[]): ASTReferenceViewDefinition;
+    getInputSchema(): Malloy.Schema;
+    getOutputSchema(): Malloy.Schema;
+    getImplicitName(): string | undefined;
+    getRefinementSchema(): Malloy.Schema;
+    isValidViewRefinement(name: string, path?: string[]): {
+        isValidViewRefinement: boolean;
+        error?: string;
+    };
+    /**
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(f: PropagationFunction): void;
+    getInheritedAnnotations(): Malloy.Annotation[];
+}
+export declare class ASTRefinementViewDefinition extends ASTObjectNode<Malloy.ViewDefinitionWithRefinement, {
+    kind: 'refinement';
+    base: ASTViewDefinition;
+    refinement: ASTViewDefinition;
+}> implements IASTViewDefinition {
+    node: Malloy.ViewDefinitionWithRefinement;
+    constructor(node: Malloy.ViewDefinitionWithRefinement);
+    isRunnable(): boolean;
+    get refinement(): ASTViewDefinition;
+    set refinement(refinement: ASTViewDefinition);
+    get base(): ASTViewDefinition;
+    set base(base: ASTViewDefinition);
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    addEmptyRefinement(): ASTSegmentViewDefinition;
+    addViewRefinement(name: string, path?: string[]): ASTReferenceViewDefinition;
+    getInputSchema(): Malloy.Schema;
+    getOutputSchema(): Malloy.Schema;
+    getRefinementSchema(): Malloy.Schema;
+    getImplicitName(): string | undefined;
+    isValidViewRefinement(name: string, path?: string[]): {
+        isValidViewRefinement: boolean;
+        error?: string;
+    };
+    /**
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(f: PropagationFunction): void;
+    getInheritedAnnotations(): Malloy.Annotation[];
+    /**
+     * @internal
+     */
+    static viewRefinementOf(view: Malloy.ViewDefinition, name: string, path?: string[]): ASTRefinementViewDefinition;
+    /**
+     * @internal
+     */
+    static segmentRefinementOf(view: Malloy.ViewDefinition): ASTRefinementViewDefinition;
+}
+export declare class ASTSegmentViewDefinition extends ASTObjectNode<Malloy.ViewDefinitionWithSegment, {
+    kind: 'segment';
+    operations: ASTViewOperationList;
+}> implements IASTViewDefinition {
+    node: Malloy.ViewDefinitionWithSegment;
+    constructor(node: Malloy.ViewDefinitionWithSegment);
+    isRunnable(): boolean;
+    get operations(): ASTViewOperationList;
+    /**
+     * @internal
+     */
+    renameOrderBys(oldName: string, newName: string): void;
+    /**
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(_f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    removeOrderBys(name: string): void;
+    reorderFields(names: string[]): void;
+    renameField(field: ASTAggregateViewOperation | ASTGroupByViewOperation | ASTNestViewOperation, name: string): void;
+    /**
+     * 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: string, direction?: Malloy.OrderByDirection): void;
+    /**
+     * 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: string): ASTNestViewOperation;
+    private firstIndexOfOperationType;
+    private DEFAULT_INSERTION_ORDER;
+    private findInsertionPoint;
+    getFieldNamed(name: string): ASTGroupByViewOperation | ASTAggregateViewOperation | ASTNestViewOperation | undefined;
+    hasFieldNamed(name: string): boolean;
+    hasField(name: string, path?: string[]): boolean;
+    getField(name: string, path?: string[]): ASTGroupByViewOperation | ASTAggregateViewOperation | ASTNestViewOperation;
+    tryGetField(name: string, path?: string[]): ASTGroupByViewOperation | ASTAggregateViewOperation | ASTNestViewOperation | undefined;
+    tryGetFieldNamed(name: string): ASTGroupByViewOperation | ASTAggregateViewOperation | ASTNestViewOperation | undefined;
+    getGroupBy(name: string): ASTGroupByViewOperation | undefined;
+    removeGroupBy(name: string): 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: string, path?: string[], rename?: string): ASTGroupByViewOperation;
+    addWhere(name: string, filter: ParsedFilter): ASTWhereViewOperation;
+    addWhere(name: string, filterString: string): ASTWhereViewOperation;
+    addWhere(name: string, path: string[], filter: ParsedFilter): ASTWhereViewOperation;
+    addWhere(name: string, path: string[], filterString: string): ASTWhereViewOperation;
+    private addTimeGroupBy;
+    addDateGroupBy(name: string, path: string[], timeframe: Malloy.DateTimeframe): ASTGroupByViewOperation;
+    addDateGroupBy(name: string, timeframe: Malloy.DateTimeframe): ASTGroupByViewOperation;
+    addTimestampGroupBy(name: string, path: string[], timeframe: Malloy.TimestampTimeframe): ASTGroupByViewOperation;
+    addTimestampGroupBy(name: string, timeframe: Malloy.TimestampTimeframe): ASTGroupByViewOperation;
+    /**
+     * 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: string, path?: string[], rename?: string): ASTAggregateViewOperation;
+    /**
+     * 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: string, rename?: string): ASTNestViewOperation;
+    private makeField;
+    private addOperation;
+    /**
+     * @internal
+     */
+    getRefinementSchema(): Malloy.Schema;
+    /**
+     * 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: number): void;
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    addEmptyRefinement(): ASTSegmentViewDefinition;
+    addViewRefinement(name: string, path?: string[]): ASTReferenceViewDefinition;
+    getInputSchema(): Malloy.Schema;
+    getOutputSchema(): Malloy.Schema;
+    getImplicitName(): string | undefined;
+    isValidViewRefinement(name: string, path?: string[]): {
+        isValidViewRefinement: boolean;
+        error?: string;
+    };
+    getInheritedAnnotations(): Malloy.Annotation[];
+}
+export declare class ASTViewOperationList extends ASTListNode<Malloy.ViewOperation, ASTViewOperation> {
+    constructor(operations: Malloy.ViewOperation[]);
+    get items(): ASTViewOperation[];
+    /**
+     * @internal
+     */
+    set items(operations: ASTViewOperation[]);
+    /**
+     * @internal
+     */
+    get segment(): ASTSegmentViewDefinition;
+}
+export type ASTViewOperation = ASTGroupByViewOperation | ASTAggregateViewOperation | ASTOrderByViewOperation | ASTNestViewOperation | ASTLimitViewOperation | ASTWhereViewOperation;
+export declare const ASTViewOperation: {
+    from(value: Malloy.ViewOperation): ASTViewOperation;
+    isLimit(x: ASTViewOperation): x is ASTLimitViewOperation;
+};
+export interface IASTAnnotatable {
+    getOrAddAnnotations(): ASTAnnotationList;
+    getInheritedTag(prefix: RegExp | string): Tag;
+    getIntrinsicTag(prefix: RegExp | string): Tag;
+    getTag(prefix: RegExp | string): Tag;
+    setTagProperty(path: Path, value: TagSetValue, prefix: string): void;
+    removeTagProperty(path: Path, prefix: string): void;
+}
+export declare class ASTOrderByViewOperation extends ASTObjectNode<Malloy.ViewOperationWithOrderBy, {
+    kind: 'order_by';
+    field_reference: ASTFieldReference;
+    direction?: Malloy.OrderByDirection;
+}> {
+    node: Malloy.ViewOperationWithOrderBy;
+    readonly kind: Malloy.ViewOperationType;
+    constructor(node: Malloy.ViewOperationWithOrderBy);
+    get fieldReference(): ASTFieldReference;
+    get name(): string;
+    get direction(): Malloy.OrderByDirection | undefined;
+    set direction(direction: Malloy.OrderByDirection | undefined);
+    get list(): ASTViewOperationList;
+    delete(): void;
+    setField(name: string): void;
+    setDirection(direction: Malloy.OrderByDirection | undefined): void;
+}
+export declare class ASTGroupByViewOperation extends ASTObjectNode<Malloy.ViewOperationWithGroupBy, {
+    kind: 'group_by';
+    name?: string;
+    field: ASTField;
+}> implements IASTAnnotatable {
+    node: Malloy.ViewOperationWithGroupBy;
+    readonly kind: Malloy.ViewOperationType;
+    constructor(node: Malloy.ViewOperationWithGroupBy);
+    get field(): ASTField;
+    get name(): string;
+    set name(name: string);
+    /**
+     * @internal
+     */
+    get list(): ASTViewOperationList;
+    /**
+     * 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: string): void;
+    /**
+     * 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(): void;
+    getFieldInfo(): Malloy.FieldInfo;
+    private get annotations();
+    private set annotations(value);
+    getOrAddAnnotations(): ASTAnnotationList;
+    getInheritedTag(prefix?: RegExp | string): Tag;
+    getIntrinsicTag(prefix?: RegExp | string): Tag;
+    getTag(prefix?: RegExp | string): Tag;
+    setTagProperty(path: Path, value?: TagSetValue, prefix?: string): void;
+    removeTagProperty(path: Path, prefix?: string): void;
+    /**
+     * @internal
+     */
+    static fromReference(name: string, path: string[] | undefined, rename: string | undefined): ASTGroupByViewOperation;
+}
+export declare class ASTAggregateViewOperation extends ASTObjectNode<Malloy.ViewOperationWithAggregate, {
+    kind: 'aggregate';
+    name?: string;
+    field: ASTField;
+}> implements IASTAnnotatable {
+    node: Malloy.ViewOperationWithAggregate;
+    readonly kind: Malloy.ViewOperationType;
+    constructor(node: Malloy.ViewOperationWithAggregate);
+    get field(): ASTField;
+    get name(): string;
+    set name(name: string);
+    get annotations(): ASTAnnotationList | undefined;
+    /**
+     * 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: string): void;
+    /**
+     * @internal
+     */
+    get list(): ASTViewOperationList;
+    delete(): void;
+    getFieldInfo(): Malloy.FieldInfo;
+    getOrAddAnnotations(): ASTAnnotationList;
+    getInheritedTag(prefix?: RegExp | string): Tag;
+    getIntrinsicTag(prefix?: RegExp | string): Tag;
+    getTag(prefix?: RegExp | string): Tag;
+    setTagProperty(path: Path, value?: TagSetValue, prefix?: string): void;
+    removeTagProperty(path: Path, prefix?: string): void;
+    addWhere(name: string, path: string[], filterString: string): ASTFilteredFieldExpression;
+    addWhere(name: string, path: string[], filter: ParsedFilter): ASTFilteredFieldExpression;
+    addWhere(name: string, filterString: string): ASTFilteredFieldExpression;
+    addWhere(name: string, filter: ParsedFilter): ASTFilteredFieldExpression;
+    /**
+     * @internal
+     */
+    static fromReference(name: string, path: string[] | undefined, rename: string | undefined): ASTAggregateViewOperation;
+}
+export declare class ASTField extends ASTObjectNode<Malloy.Field, {
+    expression: ASTExpression;
+    annotations?: ASTAnnotationList;
+}> implements IASTAnnotatable {
+    node: Malloy.Field;
+    constructor(node: Malloy.Field);
+    get expression(): ASTExpression;
+    set expression(expression: ASTExpression);
+    get name(): string;
+    get type(): Malloy.AtomicType | {
+        timeframe: Malloy.DateTimeframe;
+        kind: "date_type";
+    } | {
+        timeframe: Malloy.TimestampTimeframe;
+        kind: "timestamp_type";
+    };
+    get annotations(): ASTAnnotationList | undefined;
+    set annotations(annotations: ASTAnnotationList | undefined);
+    getReference(): Malloy.Reference;
+    getOrAddAnnotations(): ASTAnnotationList;
+    getInheritedTag(prefix?: RegExp | string): Tag;
+    getIntrinsicTag(prefix?: RegExp | string): Tag;
+    getTag(prefix?: RegExp | string): Tag;
+    setTagProperty(path: Path, value?: TagSetValue, prefix?: string): void;
+    removeTagProperty(path: Path, prefix?: string): void;
+    /**
+     * @internal
+     */
+    get segment(): ASTSegmentViewDefinition;
+    getInheritedAnnotations(): Malloy.Annotation[];
+}
+export type ASTExpression = ASTReferenceExpression | ASTFilteredFieldExpression | ASTTimeTruncationExpression;
+export declare const ASTExpression: {
+    from(value: Malloy.Expression): ASTExpression;
+};
+export declare class ASTReferenceExpression extends ASTObjectNode<Malloy.ExpressionWithFieldReference, {
+    kind: 'field_reference';
+    name: string;
+    path?: string[];
+    parameters?: ASTParameterValueList;
+}> implements IASTReference {
+    node: Malloy.ExpressionWithFieldReference;
+    readonly kind: Malloy.ExpressionType;
+    constructor(node: Malloy.ExpressionWithFieldReference);
+    get name(): string;
+    get parameters(): ASTParameterValueList | undefined;
+    set parameters(parameters: ASTParameterValueList | undefined);
+    /**
+     * @internal
+     */
+    get field(): ASTField;
+    get path(): string[] | undefined;
+    getReference(): Malloy.ExpressionWithFieldReference;
+    getFieldInfo(): Malloy.FieldInfoWithDimension | Malloy.FieldInfoWithMeasure;
+    get fieldType(): Malloy.AtomicType;
+    getInheritedAnnotations(): Malloy.Annotation[];
+    getOrAddParameters(): any;
+    setParameter(name: string, value: RawLiteralValue): void;
+    tryGetParameter(name: string): ASTParameterValue | undefined;
+}
+export declare class ASTTimeTruncationExpression extends ASTObjectNode<Malloy.ExpressionWithTimeTruncation, {
+    kind: 'time_truncation';
+    field_reference: ASTFieldReference;
+    truncation: Malloy.TimestampTimeframe;
+}> {
+    node: Malloy.ExpressionWithTimeTruncation;
+    readonly kind: Malloy.ExpressionType;
+    constructor(node: Malloy.ExpressionWithTimeTruncation);
+    getReference(): Malloy.Reference;
+    get fieldReference(): ASTFieldReference;
+    get truncation(): Malloy.TimestampTimeframe;
+    get name(): string;
+    /**
+     * @internal
+     */
+    get field(): ASTField;
+    getFieldInfo(): Malloy.FieldInfoWithDimension | Malloy.FieldInfoWithMeasure;
+    get fieldType(): {
+        timeframe: Malloy.DateTimeframe;
+        kind: "date_type";
+    } | {
+        timeframe: Malloy.TimestampTimeframe;
+        kind: "timestamp_type";
+    };
+    getInheritedAnnotations(): Malloy.Annotation[];
+}
+export declare class ASTWhere extends ASTObjectNode<Malloy.Where, {
+    filter: ASTFilter;
+}> {
+    constructor(node: Malloy.Where);
+    get filter(): ASTFilterWithFilterString;
+    get list(): ASTWhereList;
+    delete(): void;
+}
+export declare class ASTWhereList extends ASTListNode<Malloy.Where, ASTWhere> {
+    constructor(wheres: Malloy.Where[]);
+    get expression(): ASTFilteredFieldExpression;
+}
+export declare class ASTFilteredFieldExpression extends ASTObjectNode<Malloy.ExpressionWithFilteredField, {
+    kind: 'filtered_field';
+    field_reference: ASTFieldReference;
+    where: ASTWhereList;
+}> {
+    node: Malloy.ExpressionWithFilteredField;
+    readonly kind: Malloy.ExpressionType;
+    constructor(node: Malloy.ExpressionWithFilteredField);
+    getReference(): Malloy.Reference;
+    get fieldReference(): ASTFieldReference;
+    get name(): string;
+    get where(): ASTWhereList;
+    /**
+     * @internal
+     */
+    get field(): ASTField;
+    getFieldInfo(): Malloy.FieldInfoWithMeasure;
+    get fieldType(): Malloy.AtomicType;
+    getInheritedAnnotations(): Malloy.Annotation[];
+}
+export declare class ASTNestViewOperation extends ASTObjectNode<Malloy.ViewOperationWithNest, {
+    kind: 'nest';
+    name?: string;
+    view: ASTView;
+}> implements IASTAnnotatable {
+    node: Malloy.ViewOperationWithNest;
+    readonly kind: Malloy.ViewOperationType;
+    constructor(node: Malloy.ViewOperationWithNest);
+    get view(): ASTView;
+    get annotations(): ASTAnnotationList | undefined;
+    get name(): string;
+    set name(name: string);
+    /**
+     * @internal
+     */
+    get list(): ASTViewOperationList;
+    getOrAddAnnotations(): ASTAnnotationList;
+    getInheritedTag(prefix?: RegExp | string): Tag;
+    getIntrinsicTag(prefix?: RegExp | string): Tag;
+    getTag(prefix?: RegExp | string): Tag;
+    setTagProperty(path: Path, value?: TagSetValue, prefix?: string): void;
+    removeTagProperty(path: Path, prefix?: string): void;
+    delete(): void;
+    /**
+     * 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: string): void;
+    getFieldInfo(): Malloy.FieldInfo;
+    /**
+     * @internal
+     */
+    static fromReference(name: string, path: string[] | undefined, rename: string | undefined): ASTNestViewOperation;
+}
+export declare class ASTWhereViewOperation extends ASTObjectNode<Malloy.ViewOperationWithWhere, {
+    kind: 'where';
+    filter: ASTFilter;
+}> {
+    node: Malloy.ViewOperationWithWhere;
+    readonly kind: Malloy.ViewOperationType;
+    constructor(node: Malloy.ViewOperationWithWhere);
+    get filter(): ASTFilterWithFilterString;
+    /**
+     * @internal
+     */
+    get list(): ASTViewOperationList;
+    delete(): void;
+}
+export type ASTFilter = ASTFilterWithFilterString;
+export declare const ASTFilter: {
+    from(filter: Malloy.Filter): ASTFilterWithFilterString;
+};
+export declare class ASTFilterWithFilterString extends ASTObjectNode<Malloy.FilterWithFilterString, {
+    kind: 'filter_string';
+    field_reference: ASTFieldReference;
+    filter: string;
+}> {
+    node: Malloy.FilterWithFilterString;
+    readonly kind: Malloy.FilterType;
+    constructor(node: Malloy.FilterWithFilterString);
+    get fieldReference(): ASTFieldReference;
+    get filterString(): string;
+    set filterString(filter: string);
+    setFilterString(filterString: string): void;
+    getFieldInfo(): Malloy.FieldInfoWithDimension | Malloy.FieldInfoWithMeasure;
+    getFilterType(): 'string' | 'boolean' | 'number' | 'date' | 'other';
+    setFilter(filter: ParsedFilter): void;
+    getFilter(): ParsedFilter;
+}
+export declare class ASTView extends ASTObjectNode<Malloy.View, {
+    definition: ASTViewDefinition;
+    annotations?: ASTAnnotationList;
+}> implements IASTAnnotatable {
+    node: Malloy.View;
+    constructor(node: Malloy.View);
+    get definition(): ASTViewDefinition;
+    set definition(definition: ASTViewDefinition);
+    get name(): string | undefined;
+    getOrAddDefaultSegment(): ASTSegmentViewDefinition;
+    /**
+     * @internal
+     */
+    get nest(): ASTNestViewOperation;
+    getInputSchema(): Malloy.Schema;
+    getOutputSchema(): Malloy.Schema;
+    /**
+     * @internal
+     */
+    propagateUp(f: PropagationFunction): void;
+    /**
+     * @internal
+     */
+    propagateDown(f: PropagationFunction): void;
+    reorderFields(names: string[]): void;
+    get annotations(): ASTAnnotationList | undefined;
+    getOrAddAnnotations(): ASTAnnotationList;
+    getInheritedAnnotations(): Malloy.Annotation[];
+    getInheritedTag(prefix?: RegExp | string): Tag;
+    getIntrinsicTag(prefix?: RegExp | string): Tag;
+    getTag(prefix?: RegExp | string): Tag;
+    setTagProperty(path: Path, value?: TagSetValue, prefix?: string): void;
+    removeTagProperty(path: Path, prefix?: string): void;
+}
+export declare class ASTLimitViewOperation extends ASTObjectNode<Malloy.ViewOperationWithLimit, {
+    kind: 'limit';
+    limit: number;
+}> {
+    node: Malloy.ViewOperationWithLimit;
+    readonly kind: Malloy.ViewOperationType;
+    get limit(): number;
+    set limit(limit: number);
+    constructor(node: Malloy.ViewOperationWithLimit);
+    /**
+     * @internal
+     */
+    get list(): ASTViewOperationList;
+    delete(): void;
+    /**
+     * @internal
+     */
+    static validateLimit(limit: number): void;
+}
+export declare class ASTAnnotationList extends ASTListNode<Malloy.Annotation, ASTAnnotation> {
+    constructor(annotations: Malloy.Annotation[]);
+    get items(): ASTAnnotation[];
+    getInheritedAnnotations(): Malloy.Annotation[];
+    getIntrinsicTag(prefix?: RegExp | string): Tag;
+    getTag(prefix?: RegExp | string): Tag;
+    get annotations(): Malloy.Annotation[];
+    setTagProperty(path: Path, value?: TagSetValue, prefix?: string): void;
+    removeTagProperty(path: Path, prefix?: string): void;
+}
+export declare class ASTAnnotation extends ASTObjectNode<Malloy.Annotation, {
+    value: string;
+}> {
+    node: Malloy.Annotation;
+    readonly kind: Malloy.ViewOperationType;
+    get value(): string;
+    set value(value: string);
+    constructor(node: Malloy.Annotation);
+    /**
+     * @internal
+     */
+    get list(): ASTAnnotationList;
+    get index(): number;
+    delete(): void;
+    getIntrinsicTag(): Tag;
+    getTag(): Tag;
+    hasPrefix(prefix: string): boolean;
+    hasIntrinsicTagProperty(path: Path): boolean;
+    setTagProperty(path: Path, value: TagSetValue): void;
+    removeTagProperty(path: Path): void;
+}
+export {};