import { JoinType } from "../enums/join-type";
import { RowResult } from "../../core/row-result";
import { QueryCompiled } from "../../core/query-compiled";
import { MapperTable } from "../../mapper-table";
import { ProjectionBuilder } from "../projection-builder";
import { WhereBuilder } from "../where-builder";
import { DatabaseBase, DatabaseResult } from "../../definitions/database-definition";
import { MetadataTable } from "../../metadata-table";
import { QueryBuilder } from "./query-builder";
import { ExpressionOrColumn, ParamType, TypeOrderBy, ValueTypeToParse } from "../../core/utils";
import { OrderBy } from "../../core/enums/order-by";
import { HavingBuilder } from "../having-builder";
import { LambdaExpression } from "lambda-expression";
import { JoinQueryBuilder } from "./join-query-builder";
import { ProjectionsHelper } from "../../core/projections-helper";
import { ColumnRef } from "../../core/column-ref";
import { SqlCompilable } from "../sql-compilable";
import { SqlBase } from "../sql-base";
import { Observable } from "rxjs";
export declare class Query<TType> extends SqlBase<TType> {
    private _queryT;
    private _queryBuilder;
    private _queryReadableBuilder;
    private _getMapper;
    constructor(_queryT: (new () => TType) | QueryBuilder<TType>, { alias, getMapper, mapperTable, database, enableLog }?: {
        alias?: string;
        getMapper?: (tKey: (new () => any) | string) => MetadataTable<any>;
        mapperTable?: MapperTable;
        database?: DatabaseBase;
        enableLog?: boolean;
    });
    clone(): Query<TType>;
    compile(): QueryCompiled[];
    ignoreQueryFilters(): Query<TType>;
    setParamsQueryFilter(params: {
        [s: string]: ParamType;
    }): Query<TType>;
    /**
     * @link QueryBuilder
     */
    alias(): string;
    ref<TReturn>(expression: ExpressionOrColumn<TReturn, TType>): ColumnRef;
    from(query: QueryCompiled[] | SqlCompilable): Query<TType>;
    union(query: QueryCompiled[] | SqlCompilable): Query<TType>;
    unionAll(query: QueryCompiled[] | SqlCompilable): Query<TType>;
    join<TJoin>(queryTJoin: (new () => TJoin) | QueryBuilder<TJoin> | {
        _builder: () => QueryBuilder<TJoin>;
    }, onWhere: (where: WhereBuilder<TJoin>) => void, join: (joinQuery: JoinQueryBuilder<TJoin>) => void, type?: JoinType, alias?: string, ignoreQueryFilters?: boolean): Query<TType>;
    createWhere(): WhereBuilder<TType>;
    where(where: (whereCallback: WhereBuilder<TType>) => void): Query<TType>;
    whereExp(expression: LambdaExpression<TType>): Query<TType>;
    /**
     * @param projectionCallback
     */
    projection(projectionCallback: (projection: ProjectionBuilder<TType>) => void): Query<TType>;
    select(...expressions: Array<ExpressionOrColumn<any, TType>>): Query<TType>;
    limit(limit: number, offset?: number): Query<TType>;
    orderBy<TReturn>(expression: ExpressionOrColumn<TReturn, TType>, order?: OrderBy): Query<TType>;
    asc<TReturn>(expression: TypeOrderBy<TReturn, TType>): Query<TType>;
    desc<TReturn>(expression: TypeOrderBy<TReturn, TType>): Query<TType>;
    groupBy<TReturn>(expression: ExpressionOrColumn<TReturn, TType>, havingCallback?: (having: HavingBuilder<TType>, projection: ProjectionsHelper<TType>) => void): Query<TType>;
    /**
     * Find projection by alias and result index (base 1...N+1)
     * @param projectionAlias alias to find the projection
     * @returns index (base 1...N+1)
     */
    getIndexProjection<TReturn>(projectionAlias: ExpressionOrColumn<TReturn, TType>): number;
    toString(): string;
    /**
     * @link QueryReadableBuilder
     * @param cascade use cascade fetch in `hasMany` mapper (default = true)
     * @param mapper mapper table metadata
     * @param database database to execute query
     * @returns Array of `TType`
     */
    executeAndRead({ cascade, database, mapperTable }?: {
        cascade?: boolean;
        database?: DatabaseBase;
        mapperTable?: MapperTable;
    }): Observable<TType[]>;
    /**
     * Execute query and parse to @type {TType}
     * @param cascade use cascade fetch in `hasMany` mapper (default = true)
     * @returns Array of @type {TType}
     */
    toList({ cascade, database }?: {
        cascade?: boolean;
        database?: DatabaseBase;
    }): Observable<TType[]>;
    /**
     * Execute query and parse to @type {TPrimitiveType}
     * @param cascade use cascade fetch in `hasMany` mapper (default = true)
     * @returns first or default @type {TPrimitiveType}
     */
    toSingle<TPrimitiveType extends string | number | boolean>({ cascade, database, where, _default }?: {
        cascade?: boolean;
        database?: DatabaseBase;
        where?: (whereCallback: WhereBuilder<TType>) => void;
        _default?: any;
    }): Observable<TPrimitiveType>;
    /**
     * Execute query and parse to @type {TPrimitiveType}
     * @param cascade use cascade fetch in `hasMany` mapper (default = true)
     * @returns Array of @type {TPrimitiveType}
     */
    toSingleList<TPrimitiveType extends string | number | boolean>({ cascade, database }?: {
        cascade?: boolean;
        database?: DatabaseBase;
    }): Observable<TPrimitiveType[]>;
    /**
     * Allow each parse items cursor
     * @param mapper callback mapper item
     * @param cascade use cascade fetch in `hasMany` mapper (default = true)
     * @returns Array of @type {T}
     */
    mapper<T extends any>(mapper: (row: RowResult<T>) => T, { cascade, database }?: {
        cascade?: boolean;
        database?: DatabaseBase;
    }): Observable<T[]>;
    /**
     * Get count rows (count by key column) by query
     * @param where where for apply in query
     * @returns count items
     */
    count({ cascade, database, where }?: {
        cascade?: boolean;
        database?: DatabaseBase;
        where?: (whereCallback: WhereBuilder<TType>) => void;
    }): Observable<number>;
    /**
     * Get first or default item by query
     * @param where where for apply in query
     * @param cascade use cascade fetch in `hasMany` mapper (default = true)
     * @param _default default value if not found any item
     * @returns first or default item by query
     */
    firstOrDefault({ cascade, database, where, _default }?: {
        cascade?: boolean;
        database?: DatabaseBase;
        where?: (whereCallback: WhereBuilder<TType>) => void;
        _default?: any;
    }): Observable<TType>;
    /**
     * @deprecated use `.mapper`
     * Supported up to version 1.0.0
     */
    read<TReader>(cursor: any, newable: new () => TReader, mapperTable: MapperTable): TReader[];
    /**
     * @deprecated use `.mapper`
     * Supported up to version 1.0.0
     */
    toListParse<TParse>(metadataParse: MetadataTable<TParse>): Observable<TParse[]>;
    /**
     * @deprecated use `.mapper`
     * Supported up to version 1.0.0
     */
    toListTo<TReader>(newable: new () => TReader, mapperTable: MapperTable): Observable<TReader[]>;
    /**
     * @deprecated use `.mapper`
     * Supported up to version 1.0.0
     */
    toCast(): Observable<any[]>;
    /**
     * @deprecated use `.mapper`
     * Supported up to version 1.0.0
     */
    map(mapper: (row: any) => any): Observable<any[]>;
    /**
     * @hidden
     */
    _builder(): QueryBuilder<TType>;
    protected model(): TType;
    protected builderCompiled(): QueryCompiled;
    protected resolveDependencyByValue(dependency: MapperTable, value: ValueTypeToParse, index: number): QueryCompiled;
    protected resolveDependency(dependency: MapperTable): QueryCompiled;
    protected checkDatabaseResult(promise: Observable<DatabaseResult[]>): Observable<DatabaseResult[]>;
    private getMapper;
    private fetchModels;
    private fetchModel;
    protected dependencies(): MapperTable[];
}