import {
    ObjectLiteral, OrderByCondition,
    WhereExpression, Brackets,
    // SelectQueryBuilderOption,
} from 'typeorm'
import { QueryBuilder } from './QueryBuilder'

// export declare type SelectQueryBuilderOption = "disable-global-order" | "create-pojo";

/**
 * Allows to build complex sql queries in a fashion way and execute those queries.
 */
export declare class SelectQueryBuilder<Entity> extends QueryBuilder<Entity> implements WhereExpression {
    /**
     * Gets generated sql query without parameters being replaced.
     */
    getQuery(): string;
    /**
     * Creates a subquery - query that can be used inside other queries.
     */
    subQuery(): SelectQueryBuilder<any>;
    /**
     * Creates SELECT query.
     * Replaces all previous selections if they exist.
     */
    // select(): this;
    // /**
    //  * Creates SELECT query.
    //  * Replaces all previous selections if they exist.
    //  */
    // select(selection: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, selectionAliasName?: string): this;
    // /**
    //  * Creates SELECT query and selects given data.
    //  * Replaces all previous selections if they exist.
    //  */
    // select(selection: string, selectionAliasName?: string): this;
    /**
     * Creates SELECT query and selects given data.
     * Replaces all previous selections if they exist.
     */
    // select(selection: string[]): this;
    select(selection: any[]): this;
    /**
     * Adds new selection to the SELECT query.
     */
    addSelect(selection: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, selectionAliasName?: string): this;
    /**
     * Adds new selection to the SELECT query.
     */
    // addSelect(selection: string, selectionAliasName?: string): this;
    /**
     * Adds new selection to the SELECT query.
     */
    // addSelect(selection: string[]): this;
    addSelect(selection: any[]): this;
    /**
     * Sets whether the selection is DISTINCT.
     */
    distinct(distinct?: boolean): this;
    /**
     * Sets the distinct on clause for Postgres.
     */
    distinctOn(distinctOn: string[]): this;
    // /**
    //  * Specifies FROM which entity's table select/update/delete will be executed.
    //  * Also sets a main string alias of the selection data.
    //  * Removes all previously set from-s.
    //  */
    // from<T>(entityTarget: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, aliasName: string): SelectQueryBuilder<T>;
    // /**
    //  * Specifies FROM which entity's table select/update/delete will be executed.
    //  * Also sets a main string alias of the selection data.
    //  * Removes all previously set from-s.
    //  */
    // from<T>(entityTarget: ObjectType<T> | string, aliasName: string): SelectQueryBuilder<T>;
    // /**
    //  * Specifies FROM which entity's table select/update/delete will be executed.
    //  * Also sets a main string alias of the selection data.
    //  */
    // addFrom<T>(entityTarget: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, aliasName: string): SelectQueryBuilder<T>;
    // /**
    //  * Specifies FROM which entity's table select/update/delete will be executed.
    //  * Also sets a main string alias of the selection data.
    //  */
    // addFrom<T>(entityTarget: ObjectType<T> | string, aliasName: string): SelectQueryBuilder<T>;
    // /**
    //  * INNER JOINs (without selection) given subquery.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoin(subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs (without selection) entity's property.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoin(property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs (without selection) given entity's table.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoin(entity: Function | string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs (without selection) given table.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoin(tableName: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs (without selection) given subquery.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoin(subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs (without selection) entity's property.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoin(property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs (without selection) entity's table.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoin(entity: Function | string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs (without selection) given table.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoin(tableName: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    /**
     * INNER JOINs given subquery and adds all selection properties to SELECT..
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    innerJoinAndSelect(subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    /**
     * INNER JOINs entity's property and adds all selection properties to SELECT.
     * Given entity property should be a relation.
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    // innerJoinAndSelect(property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    innerJoinAndSelect(property: any, alias: any, condition?: string, parameters?: ObjectLiteral): this;
    /**
     * INNER JOINs entity and adds all selection properties to SELECT.
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    // innerJoinAndSelect(entity: Function | string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    /**
     * INNER JOINs table and adds all selection properties to SELECT.
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    // innerJoinAndSelect(tableName: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    /**
     * LEFT JOINs given subquery and adds all selection properties to SELECT..
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    leftJoinAndSelect(subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    /**
     * LEFT JOINs entity's property and adds all selection properties to SELECT.
     * Given entity property should be a relation.
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    // leftJoinAndSelect(property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    leftJoinAndSelect(property: any, alias: any, condition?: string, parameters?: ObjectLiteral): this;
    /**
     * LEFT JOINs entity and adds all selection properties to SELECT.
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    // leftJoinAndSelect(entity: Function | string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    /**
     * LEFT JOINs table and adds all selection properties to SELECT.
     * You also need to specify an alias of the joined data.
     * Optionally, you can add condition and parameters used in condition.
     */
    // leftJoinAndSelect(tableName: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs given subquery, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapMany(mapToProperty: string, subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>,
    //      alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs entity's property, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapMany(mapToProperty: string, property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs entity's table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapMany(mapToProperty: string, entity: Function | string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapMany(mapToProperty: string, tableName: string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs given subquery, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapOne(mapToProperty: string, subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>,
    //      alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs entity's property, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapOne(mapToProperty: string, property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs entity's table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapOne(mapToProperty: string, entity: Function | string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  * INNER JOINs table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // innerJoinAndMapOne(mapToProperty: string, tableName: string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs given subquery, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapMany(mapToProperty: string, subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>,
    //      alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs entity's property, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapMany(mapToProperty: string, property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs entity's table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapMany(mapToProperty: string, entity: Function | string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapMany(mapToProperty: string, tableName: string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs given subquery, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapOne(mapToProperty: string, subQueryFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>,
    //      alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs entity's property, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * Given entity property should be a relation.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapOne(mapToProperty: string, property: string, alias: string, condition?: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs entity's table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapOne(mapToProperty: string, entity: Function | string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  * LEFT JOINs table, SELECTs the data returned by a join and MAPs all that data to some entity's property.
    //  * This is extremely useful when you want to select some data and map it to some virtual property.
    //  * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
    //  * You also need to specify an alias of the joined data.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // leftJoinAndMapOne(mapToProperty: string, tableName: string, alias: string, condition: string, parameters?: ObjectLiteral): this;
    // /**
    //  */
    // /**
    //  */
    // /**
    //  */
    // /**
    //  */
    // /**
    //  * LEFT JOINs relation id and maps it into some entity's property.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // loadRelationIdAndMap(mapToProperty: string, relationName: string, options?: {
    //     disableMixedMap?: boolean;
    // }): this;
    // /**
    //  * LEFT JOINs relation id and maps it into some entity's property.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // loadRelationIdAndMap(mapToProperty: string, relationName: string, alias: string, queryBuilderFactory: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>): this;
    // /**
    //  * Counts number of entities of entity's relation and maps the value into some entity's property.
    //  * Optionally, you can add condition and parameters used in condition.
    //  */
    // loadRelationCountAndMap(mapToProperty: string, relationName: string, aliasName?: string,
    //      queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>): this;
    // /**
    //  * Loads all relation ids for all relations of the selected entity.
    //  * All relation ids will be mapped to relation property themself.
    //  * If array of strings is given then loads only relation ids of the given properties.
    //  */
    // loadAllRelationIds(options?: {
    //     relations?: string[];
    //     disableMixedMap?: boolean;
    // }): this;
    /**
     * Sets WHERE condition in the query builder.
     * If you had previously WHERE expression defined,
     * calling this function will override previously set WHERE conditions.
     * Additionally you can add parameters used in where expression.
     */
    where(where: Brackets | string | ((qb: this) => string) | ObjectLiteral | ObjectLiteral[], parameters?: ObjectLiteral): this;
    /**
     * Adds new AND WHERE condition in the query builder.
     * Additionally you can add parameters used in where expression.
     */
    andWhere(where: string | Brackets | ((qb: this) => string), parameters?: ObjectLiteral): this;
    /**
     * Adds new OR WHERE condition in the query builder.
     * Additionally you can add parameters used in where expression.
     */
    orWhere(where: Brackets | string | ((qb: this) => string), parameters?: ObjectLiteral): this;
    /**
     * Adds new AND WHERE with conditions for the given ids.
     *
     * Ids are mixed.
     * It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
     * If you have multiple primary keys you need to pass object with property names and values specified,
     * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
     */
    whereInIds(ids: any | any[]): this;
    /**
     * Adds new AND WHERE with conditions for the given ids.
     *
     * Ids are mixed.
     * It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
     * If you have multiple primary keys you need to pass object with property names and values specified,
     * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
     */
    andWhereInIds(ids: any | any[]): this;
    /**
     * Adds new OR WHERE with conditions for the given ids.
     *
     * Ids are mixed.
     * It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
     * If you have multiple primary keys you need to pass object with property names and values specified,
     * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
     */
    orWhereInIds(ids: any | any[]): this;
    /**
     * Sets HAVING condition in the query builder.
     * If you had previously HAVING expression defined,
     * calling this function will override previously set HAVING conditions.
     * Additionally you can add parameters used in where expression.
     */
    having(having: string, parameters?: ObjectLiteral): this;
    /**
     * Adds new AND HAVING condition in the query builder.
     * Additionally you can add parameters used in where expression.
     */
    andHaving(having: string, parameters?: ObjectLiteral): this;
    /**
     * Adds new OR HAVING condition in the query builder.
     * Additionally you can add parameters used in where expression.
     */
    orHaving(having: string, parameters?: ObjectLiteral): this;
    /**
     * Sets GROUP BY condition in the query builder.
     * If you had previously GROUP BY expression defined,
     * calling this function will override previously set GROUP BY conditions.
     */
    groupBy(): this;
    /**
     * Sets GROUP BY condition in the query builder.
     * If you had previously GROUP BY expression defined,
     * calling this function will override previously set GROUP BY conditions.
     */
    groupBy(groupBy: string): this;
    /**
     * Adds GROUP BY condition in the query builder.
     */
    addGroupBy(groupBy: string): this;
    /**
     * Sets ORDER BY condition in the query builder.
     * If you had previously ORDER BY expression defined,
     * calling this function will override previously set ORDER BY conditions.
     *
     * Calling order by without order set will remove all previously set order bys.
     */
    orderBy(): this;
    /**
     * Sets ORDER BY condition in the query builder.
     * If you had previously ORDER BY expression defined,
     * calling this function will override previously set ORDER BY conditions.
     */
    orderBy(sort: string, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): this;
    /**
     * Sets ORDER BY condition in the query builder.
     * If you had previously ORDER BY expression defined,
     * calling this function will override previously set ORDER BY conditions.
     */
    orderBy(order: OrderByCondition): this;
    /**
     * Adds ORDER BY condition in the query builder.
     */
    addOrderBy(sort: string, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): this;
    /**
     * Set's LIMIT - maximum number of rows to be selected.
     * NOTE that it may not work as you expect if you are using joins.
     * If you want to implement pagination, and you are having join in your query,
     * then use instead take method instead.
     */
    limit(limit?: number): this;
    /**
     * Set's OFFSET - selection offset.
     * NOTE that it may not work as you expect if you are using joins.
     * If you want to implement pagination, and you are having join in your query,
     * then use instead skip method instead.
     */
    offset(offset?: number): this;
    /**
     * Sets maximal number of entities to take.
     */
    take(take?: number): this;
    /**
     * Sets number of entities to skip.
     */
    skip(skip?: number): this;
    /**
     * Sets locking mode.
     */
    setLock(lockMode: 'optimistic', lockVersion: number): this;
    // /**
    //  * Sets locking mode.
    //  */
    // setLock(lockMode: 'optimistic', lockVersion: Date): this;
    /**
     * Sets locking mode.
     */
    // setLock(lockMode: 'pessimistic_read' | 'pessimistic_write' | 'dirty_read'): this;
    setLock(lockMode: 'pessimistic_read' | 'pessimistic_write'): this;
    /**
     * Gets first raw result returned by execution of generated query builder sql.
     */
    getRawOne(): Promise<any>;
    /**
     * Gets all raw results returned by execution of generated query builder sql.
     */
    getRawMany(): Promise<any[]>;
    /**
     * Executes sql generated by query builder and returns object with raw results and entities created from them.
     */
    getRawAndEntities(): Promise<{
        entities: Entity[];
        raw: any[];
    }>;
    /**
     * Gets single entity returned by execution of generated query builder sql.
     */
    // getOne(): Promise<Entity | undefined>; // 不适合返回undefined应该由应用进行断言处理，简化上层应用的书写编码体验。
    getOne(): Promise<Entity>;
    /**
     * Gets entities returned by execution of generated query builder sql.
     */
    getMany(): Promise<Entity[]>;
    /**
     * Gets count - number of entities selected by sql generated by this query builder.
     * Count excludes all limitations set by setFirstResult and setMaxResults methods call.
     */
    getCount(): Promise<number>;
    /**
     * Executes built SQL query and returns entities and overall entities count (without limitation).
     * This method is useful to build pagination.
     */
    getManyAndCount(): Promise<[Entity[], number]>;
    // /**
    //  * Executes built SQL query and returns raw data stream.
    //  */
    // stream(): Promise<ReadStream>;
    /**
     * Enables or disables query result caching.
     */
    cache(enabled: boolean): this;
    /**
     * Enables query result caching and sets in milliseconds in which cache will expire.
     * If not set then global caching time will be used.
     */
    cache(milliseconds: number): this;
    /**
     * Enables query result caching and sets cache id and milliseconds in which cache will expire.
     */
    cache(id: any, milliseconds?: number): this;
    // /**
    //  * Sets extra options that can be used to configure how query builder works.
    //  */
    // setOption(option: SelectQueryBuilderOption): this;
    // protected join(direction: "INNER" | "LEFT", entityOrProperty: Function | string
    //  | ((qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>), aliasName: string, condition?: string,
    //      parameters?: ObjectLiteral, mapToProperty?: string, isMappingMany?: boolean): void;
    // /**
    //  * Creates "SELECT FROM" part of SQL query.
    //  */
    // protected createSelectExpression(): string;
    // /**
    //  * Creates select | select distinct part of SQL query.
    //  */
    // protected createSelectDistinctExpression(): string;
    // /**
    //  * Creates "JOIN" part of SQL query.
    //  */
    // protected createJoinExpression(): string;
    // /**
    //  * Creates "GROUP BY" part of SQL query.
    //  */
    // protected createGroupByExpression(): string;
    // /**
    //  * Creates "ORDER BY" part of SQL query.
    //  */
    // protected createOrderByExpression(): string;
    // /**
    //  * Creates "LIMIT" and "OFFSET" parts of SQL query.
    //  */
    // protected createLimitOffsetExpression(): string;
    // /**
    //  * Creates "LOCK" part of SQL query.
    //  */
    // protected createLockExpression(): string;
    // /**
    //  * Creates "HAVING" part of SQL query.
    //  */
    // protected createHavingExpression(): string;
    // protected buildEscapedEntityColumnSelects(aliasName: string, metadata: EntityMetadata): SelectQuery[];
    // protected findEntityColumnSelects(aliasName: string, metadata: EntityMetadata): SelectQuery[];
    // protected executeCountQuery(queryRunner: QueryRunner): Promise<number>;
    // /**
    //  * Executes sql generated by query builder and returns object with raw results and entities created from them.
    //  */
    // protected executeEntitiesAndRawResults(queryRunner: QueryRunner): Promise<{
    //     entities: Entity[];
    //     raw: any[];
    // }>;
    // protected createOrderByCombinedWithSelectExpression(parentAlias: string): [string, OrderByCondition];
    // /**
    //  * Loads raw results from the database.
    //  */
    // protected loadRawResults(queryRunner: QueryRunner): Promise<any>;
    // /**
    //  * Merges into expression map given expression map properties.
    //  */
    // protected mergeExpressionMap(expressionMap: Partial<QueryExpressionMap>): this;
    // /**
    //  * Normalizes a give number - converts to int if possible.
    //  */
    // protected normalizeNumber(num: any): any;
    // /**
    //  * Creates a query builder used to execute sql queries inside this query builder.
    //  */
    // protected obtainQueryRunner(): QueryRunner;
}