import type { OrderDir, QueryExecutor, WhereCondition } from "../core/query.js";
import type { SQLChunk } from "../core/sql.js";
import { type Table } from "../schema/table.js";
import type { ColumnConfig, InferColumnType, InferTable } from "../types/index.js";
import type { CTEBuilder } from "./cte.js";
export type SelectedFields = {
    [key: string]: ColumnConfig<any, any, any, any> | SQLChunk<any> | SelectedFields;
};
export type InferSelection<T extends SelectedFields> = {
    [K in keyof T]: T[K] extends ColumnConfig<any, any, any, any> ? InferColumnType<T[K]> : T[K] extends SQLChunk<infer U> ? U : T[K] extends SelectedFields ? InferSelection<T[K]> : never;
};
export declare class SelectBuilder<TColumns extends Record<string, ColumnConfig>, TResult = InferTable<TColumns>> implements PromiseLike<TResult[]> {
    private _table;
    private _executor;
    private _where;
    private _orderBy;
    private _groupBy;
    private _having;
    private _limit?;
    private _offset?;
    private _select?;
    private _selection?;
    private _joins;
    private _isNestedOutput;
    private _with;
    private _setOperations;
    private _comment?;
    constructor(table: Table<string, TColumns> | CTEBuilder, executor: QueryExecutor, selection?: SelectedFields);
    then<TResult1 = TResult[], TResult2 = never>(onfulfilled?: ((value: TResult[]) => TResult1 | PromiseLike<TResult1>) | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined): Promise<TResult1 | TResult2>;
    single(): Promise<TResult | null>;
    select(...columns: ((keyof TColumns & string) | ColumnConfig)[]): this;
    with(...ctes: CTEBuilder[]): this;
    union(other: {
        toSQL(): SQLChunk;
    }): this;
    unionAll(other: {
        toSQL(): SQLChunk;
    }): this;
    intersect(other: {
        toSQL(): SQLChunk;
    }): this;
    except(other: {
        toSQL(): SQLChunk;
    }): this;
    comment(tag: string): this;
    where(condition: WhereCondition<TColumns>): this;
    orderBy(column: (keyof TColumns & string) | (string & {}) | ColumnConfig | SQLChunk<any>, dir?: OrderDir): this;
    groupBy(...columns: ((keyof TColumns & string) | (string & {}) | ColumnConfig | SQLChunk<any>)[]): this;
    having(condition: WhereCondition<TColumns>): this;
    limit(n: number): this;
    offset(n: number): this;
    paginate(page: number, pageSize: number): this;
    cursorPaginate(cursor: string | number | Date | null | undefined, limit: number, cursorColumn?: (keyof TColumns & string) | ColumnConfig): this;
    as<TAlias extends string>(aliasName: TAlias): Table<TAlias, Record<string, ColumnConfig<any, any, any, any>>>;
    join(rawClause: string): this;
    private _buildJoin;
    innerJoin(table: Table<any, any> | CTEBuilder, condition: SQLChunk): this;
    leftJoin(table: Table<any, any> | CTEBuilder, condition: SQLChunk): this;
    rightJoin(table: Table<any, any> | CTEBuilder, condition: SQLChunk): this;
    fullJoin(table: Table<any, any> | CTEBuilder, condition: SQLChunk): this;
    private _buildSelection;
    toSQL(): SQLChunk;
}
export declare class SelectBuilderIntermediate<TSelection extends SelectedFields | undefined = undefined> {
    private _executor;
    private _selection?;
    constructor(_executor: QueryExecutor, _selection?: TSelection | undefined);
    from<TName extends string, TColumns extends Record<string, ColumnConfig<any, any, any, any>>>(table: Table<TName, TColumns> | CTEBuilder): SelectBuilder<TColumns, TSelection extends SelectedFields ? InferSelection<TSelection> : InferTable<TColumns>>;
}
//# sourceMappingURL=select.d.ts.map