import { ProjectionCompiled } from "../projection-compiled";
import { UnionType } from "../../core/union-type";
import { ProjectionBuilder } from "../projection-builder";
import { ExpressionOrColumn, ParamType, TypeOrderBy } from "../../core/utils";
import { WhereBuilder } from "../where-builder";
import { OrderBy } from "../../core/enums/order-by";
import { WhereCompiled } from "../where-compiled";
import { QueryCompiled } from "../../core/query-compiled";
import { LambdaExpression } from "lambda-expression";
import { JoinQueryBuilderContract } from "./join-query-builder-contract";
import { QueryBuilderBaseContract } from "./query-builder-base-contract";
import { HavingBuilder } from "../having-builder";
import { ProjectionsHelper } from "../../core/projections-helper";
import { BuilderCompiled } from "../../core/builder-compiled";
import { ColumnRef } from "../../core/column-ref";
import { MapperTable } from "../../mapper-table";
import { SqlCompilable } from "../sql-compilable";
import { SqlBaseBuilder } from "../sql-base-builder";
import { MetadataTable } from "../../metadata-table";
import { QueryBuilder } from "./query-builder";
import { ProjectionModel } from "../projection-model";
export declare abstract class QueryBuilderBase<T, TQuery extends QueryBuilderBase<T, TQuery>> extends SqlBaseBuilder<T> implements QueryBuilderBaseContract<T, QueryBuilderBase<T, TQuery>> {
    protected _getMapper?: (tKey: (new () => any) | string) => MetadataTable<any>;
    get alias(): string;
    get tablename(): string;
    protected _groupBy: string;
    protected _limit: BuilderCompiled;
    protected _orderBy: string;
    protected _having: WhereCompiled;
    protected _projections: ProjectionModel[];
    protected _joinParams: ParamType[];
    protected _ignoreQueryFilter: boolean;
    private readonly GROUP_BY;
    private readonly HAVING;
    private readonly ORDER_BY;
    private readonly LIMIT;
    private readonly OFFSET;
    private _paramsQueryFilter;
    private _joinsQuery;
    private _unionsQuery;
    private _fromParams;
    constructor(queryT: (new () => T) | QueryBuilder<T>, mapperTable: MapperTable, alias?: string, _getMapper?: (tKey: (new () => any) | string) => MetadataTable<any>);
    getAlias(tKey: (new () => any) | string): string;
    clone(): TQuery;
    ref<TReturn>(expression: ExpressionOrColumn<TReturn, T>, alias?: string): ColumnRef;
    hasAlias(alias: string): boolean;
    from(query: QueryCompiled[] | SqlCompilable): TQuery;
    unionAll(query: QueryCompiled[] | SqlCompilable): TQuery;
    union(query: QueryCompiled[] | SqlCompilable, type?: UnionType): TQuery;
    createWhere(): WhereBuilder<T>;
    where(whereCallback: (where: WhereBuilder<T>) => void): TQuery;
    /**
     * Where with expression Lambda
     * #Experimental
     * @param {LambdaExpression<T>} expression
     * @returns {TQuery}
     * @memberof QueryBuilderBase
     */
    whereExp(expression: LambdaExpression<T>): TQuery;
    projection(projectionCallback: (projection: ProjectionBuilder<T>) => void): TQuery;
    select(...expressions: Array<ExpressionOrColumn<any, T>>): TQuery;
    orderBy<TReturn>(expression: TypeOrderBy<TReturn, T>, order?: OrderBy): TQuery;
    asc<TReturn>(expression: TypeOrderBy<TReturn, T>): TQuery;
    desc<TReturn>(expression: TypeOrderBy<TReturn, T>): TQuery;
    groupBy<TReturn>(expression: ExpressionOrColumn<TReturn, T>, havingCallback?: (having: HavingBuilder<T>, projection: ProjectionsHelper<T>) => void): TQuery;
    limit(limit: number, offset?: number): TQuery;
    /**
     * 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, T>): number;
    ignoreQueryFilters(): TQuery;
    enableQueryFilters(): TQuery;
    setParamsQueryFilter(params: {
        [s: string]: ParamType;
    }): TQuery;
    compileTable(): string;
    compile(): QueryCompiled;
    protected whereCompile(baseWhereCompiled: WhereCompiled): WhereCompiled;
    protected createProjectionBuilder(addAliasTableToAlias?: boolean, addAliasDefault?: boolean): ProjectionBuilder<T>;
    protected addJoin<TJoin, TQueryJoin extends JoinQueryBuilderContract<TJoin, TQueryJoin>>(joinQuery: JoinQueryBuilderContract<TJoin, TQueryJoin>): void;
    protected setDefaultColumns(): void;
    protected getColumnsCompiled(): ProjectionCompiled;
    protected compileJoin(): QueryCompiled;
    protected buildBase(): QueryCompiled;
    protected compileGroupBy(groupBy: string, addCommand?: boolean): void;
    protected compileHaving(having: WhereCompiled, addCommand?: boolean): void;
    protected compileOrderBy(orderBy: string, addCommand?: boolean): void;
    protected abstract _getInstance(): TQuery;
    private buildUnions;
    private buildProjections;
    private compileTableJoins;
}