import type { FieldDef, BooleanFieldDef, DateFieldDef, StringFieldDef, JSONFieldDef, NumberFieldDef, TimestampFieldDef, NativeUnsupportedFieldDef, JoinFieldDef, Argument, PrepareResultOptions, AtomicFieldDef, BasicAtomicDef, FilterCondition, RefToField, StructDef, TurtleDef, TurtleDefPlusFilters, SourceDef, Query } from './malloy_types';
import type { EventStream } from '../runtime_types';
import type { Tag } from '@malloydata/malloy-tag';
import type { Dialect } from '../dialect';
declare abstract class QueryNode {
    readonly referenceId: string;
    constructor(referenceId?: string);
    abstract getIdentifier(): string;
    getChildByName(_name: string): QueryField | undefined;
}
export declare class QueryField extends QueryNode {
    fieldDef: FieldDef;
    parent: QueryStruct;
    constructor(fieldDef: FieldDef, parent: QueryStruct, referenceId?: string);
    getIdentifier(): string;
    getJoinableParent(): QueryStruct;
    isAtomic(): boolean;
    getFullOutputName(): string;
    isNestedInParent(parentDef: FieldDef): boolean;
    isArrayElement(parentDef: FieldDef): boolean;
    includeInWildcard(): boolean;
}
export declare abstract class QueryAtomicField<T extends AtomicFieldDef> extends QueryField {
    fieldDef: T;
    constructor(fieldDef: T, parent: QueryStruct, refId?: string);
    includeInWildcard(): boolean;
    getFilterList(): FilterCondition[];
}
export declare class QueryFieldBoolean extends QueryAtomicField<BooleanFieldDef> {
}
export declare class QueryFieldDate extends QueryAtomicField<DateFieldDef> {
}
export declare class QueryFieldDistinctKey extends QueryAtomicField<StringFieldDef> {
}
export declare class QueryFieldJSON extends QueryAtomicField<JSONFieldDef> {
}
export declare class QueryFieldNumber extends QueryAtomicField<NumberFieldDef> {
}
export declare class QueryFieldString extends QueryAtomicField<StringFieldDef> {
}
export declare class QueryFieldStruct extends QueryField {
    queryStruct: QueryStruct;
    fieldDef: JoinFieldDef;
    constructor(jfd: JoinFieldDef, sourceArguments: Record<string, Argument> | undefined, parent: QueryStruct, prepareResultOptions: PrepareResultOptions, referenceId?: string);
    getJoinableParent(): QueryStruct;
    getFullOutputName(): string;
    includeInWildcard(): boolean;
}
export declare class QueryFieldTimestamp extends QueryAtomicField<TimestampFieldDef> {
}
export declare class QueryFieldUnsupported extends QueryAtomicField<NativeUnsupportedFieldDef> {
}
export type QueryBasicField = QueryAtomicField<BasicAtomicDef>;
export declare function isAggregateField(f: QueryField): boolean;
export declare function isCalculatedField(f: QueryField): boolean;
export declare function isScalarField(f: QueryField): boolean;
export declare function isBasicAggregate(f: QueryField): f is QueryBasicField;
export declare function isBasicCalculation(f: QueryField): f is QueryBasicField;
export declare function isBasicScalar(f: QueryField): f is QueryBasicField;
export interface ParentQueryStruct {
    struct: QueryStruct;
}
export interface ModelRootInterface {
    eventStream?: EventStream;
}
export interface ParentQueryModel {
    model: ModelRootInterface;
}
/** Structure object as it is used to build a query */
export declare class QueryStruct {
    structDef: StructDef;
    readonly sourceArguments: Record<string, Argument> | undefined;
    readonly prepareResultOptions: PrepareResultOptions;
    parent: QueryStruct | undefined;
    model: ModelRootInterface;
    nameMap: Map<string, QueryField>;
    pathAliasMap: Map<string, string>;
    dialect: Dialect;
    connectionName: string;
    /**
     * For fields which are a record, but the value is an expression
     * we capture the context needed to generate the expression in
     * QueryQuery.expandRecordExpressions. Later in the compilation if a
     * reference passes through this struct, this will call
     * the expression compiler with the correct context
     * to compute the record value.
     */
    computeRecordExpression?: () => string;
    recordValue?: string;
    constructor(structDef: StructDef, sourceArguments: Record<string, Argument> | undefined, parent: ParentQueryStruct | ParentQueryModel, prepareResultOptions: PrepareResultOptions);
    private static turtleFieldMaker;
    static registerTurtleFieldMaker(maker: (field: TurtleDef, parent: QueryStruct) => QueryField): void;
    private _modelTag;
    modelCompilerFlags(): Tag;
    protected findFirstDialect(): string;
    maybeEmitParameterizedSourceUsage(): void;
    private resolveParentParameterReferences;
    private _arguments;
    arguments(): Record<string, Argument>;
    private addFieldsFromFieldList;
    getAliasIdentifier(): string;
    getSQLIdentifier(): string;
    sqlSimpleChildReference(name: string): string;
    getIdentifier(): string;
    getFullOutputName(): string;
    unnestWithNumbers(): boolean;
    getJoinableParent(): QueryStruct;
    addFieldToNameMap(as: string, n: QueryField): void;
    /** the the primary key or throw an error. */
    getPrimaryKeyField(fieldDef: FieldDef): QueryBasicField;
    /**
     * called after all structure has been loaded.  Examine this structure to see
     * if if it is based on a query and if it is, add the output fields (unless
     * they exist) to the structure.
     *
     * finalOutputStruct exists so that query_node doesn't need to
     * to import query_query
     */
    resolveQueryFields(finalOutputStruct: (query: Query, options: PrepareResultOptions | undefined) => SourceDef | undefined): void;
    getModel(): ModelRootInterface;
    get eventStream(): EventStream | undefined;
    setParent(parent: ParentQueryStruct | ParentQueryModel): void;
    /** makes a new queryable field object from a fieldDef */
    makeQueryField(field: FieldDef, referenceId?: string): QueryField;
    root(): QueryStruct;
    primaryKey(): QueryBasicField | undefined;
    getChildByName(name: string): QueryField | undefined;
    /** convert a path into a field reference */
    getFieldByName(path: string[]): QueryField;
    getQueryFieldByName(name: string[]): QueryField;
    getQueryFieldReference(f: RefToField): QueryField;
    getDimensionOrMeasureByName(name: string[]): QueryField;
    /** returns a query object for the given name */
    getDimensionByName(name: string[]): QueryBasicField;
    /** returns a query object for the given name */
    getStructByName(name: string[]): QueryStruct;
    getDistinctKey(): QueryBasicField;
    applyStructFiltersToTurtleDef(turtleDef: TurtleDef | TurtleDefPlusFilters): TurtleDef;
}
export {};