import { type HasQuery, type HasSelection, type HasSql, type HasTarget, internalData, internalQuery, internalSelection, internalSql } from '../Internal.js';
import type { IsMysql, IsPostgres, QueryMeta } from '../MetaData.js';
import { type QueryData, SingleQuery } from '../Queries.js';
import { type IsNullable, type MakeNullable, type Selection, type SelectionRecord, type SelectionRow } from '../Selection.js';
import { Sql } from '../Sql.js';
import type { Table, TableDefinition, TableFields } from '../Table.js';
import type { Expand } from '../Types.js';
import type { Field, StripFieldMeta } from '../expr/Field.js';
import type { Input as UserInput } from '../expr/Input.js';
import { type CTE } from './CTE.js';
import type { CompoundSelect, SelectQuery, UnionQuery } from './Query.js';
type UnionTarget<Input, Meta extends QueryMeta> = UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>);
export declare class SelectFirst<Input, Meta extends QueryMeta = QueryMeta> extends SingleQuery<SelectionRow<Input>, Meta> implements HasQuery<SelectionRow<Input>> {
    readonly [internalData]: QueryData<Meta> & SelectQuery;
    constructor(data: QueryData<Meta> & SelectQuery);
    get [internalSelection](): Selection;
    get [internalQuery](): Sql<SelectionRow<Input>>;
    get [internalSql](): Sql<SelectionRow<Input>>;
}
export declare abstract class UnionBase<Input, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Array<SelectionRow<Input>>, Meta> implements HasSelection {
    #private;
    readonly [internalData]: QueryData<Meta>;
    abstract [internalSelection]: Selection;
    constructor(data: QueryData<Meta> & {
        compound: CompoundSelect;
    });
    as<Name extends string>(alias: Name): SubQuery<Input, Name>;
    union(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
    unionAll(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
    intersect(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
    intersectAll<Meta extends IsPostgres | IsMysql>(this: UnionBase<Input, Meta>, target: UnionTarget<Input, Meta>): Union<Input, Meta>;
    except(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
    exceptAll<Meta extends IsPostgres | IsMysql>(this: UnionBase<Input, Meta>, target: UnionTarget<Input, Meta>): Union<Input, Meta>;
}
export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<StripFieldMeta<Input>, Meta> implements HasSelection, SelectBase<Input, Meta>, HasQuery<Array<SelectionRow<Input>>> {
    #private;
    readonly [internalData]: QueryData<Meta> & SelectQuery;
    constructor(data: QueryData<Meta> & SelectQuery);
    from(from: HasTarget | Sql): Select<Input, Meta>;
    leftJoin(leftJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
    rightJoin(rightJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
    innerJoin(innerJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
    fullJoin(fullJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
    crossJoin(crossJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
    where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
    groupBy(...groupBy: Array<HasSql>): Select<Input, Meta>;
    having(having: HasSql<boolean> | ((self: Input) => HasSql<boolean>)): Select<Input, Meta>;
    orderBy(...orderBy: Array<HasSql>): Select<Input, Meta>;
    limit(limit: UserInput<number>): Select<Input, Meta>;
    offset(offset: UserInput<number>): Select<Input, Meta>;
    $dynamic(): this;
    $first(): SelectFirst<Input, Meta>;
    get [internalSelection](): Selection;
    get [internalQuery](): Sql<Array<SelectionRow<Input>>>;
    get [internalSql](): Sql<SelectionRow<Input>>;
}
export type SubQuery<Input, Name extends string = string> = Input & HasTarget<Name> & HasSelection;
export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<StripFieldMeta<Input>, Meta>, HasSql<SelectionRow<Input>> {
    where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
    groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
    having(having: HasSql<boolean>): Select<Input, Meta>;
    orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
    limit(limit: UserInput<number>): Select<Input, Meta>;
    offset(offset: UserInput<number>): Select<Input, Meta>;
    $dynamic(): this;
}
export interface WithoutSelection<Meta extends QueryMeta> {
    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
    from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
    from<Input>(from: CTE<Input>): SelectionFrom<Input, Meta>;
}
export interface WithSelection<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta>, HasSql<SelectionRow<Input>> {
    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
    from(from: HasTarget): SelectionFrom<Input, Meta>;
    from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
    from(from: HasSql): Select<Input, Meta>;
}
export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends SelectBase<Input, Meta> {
    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
    leftJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & MakeNullable<Record<Name, Input>>>, Meta>;
    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & Record<Name, TableFields<Definition>>>, Meta>;
    rightJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & Record<Name, Input>>, Meta>;
    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, TableFields<Definition>>>, Meta>;
    innerJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, Input>>, Meta>;
    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
    fullJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, Input>>>, Meta>;
}
type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
    [K in keyof Input]: Input[K] extends Field<infer T, TableName> ? HasSql<T | null> : Input[K] extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input[K] extends Record<string, Field<unknown, TableName> | HasSql<unknown>> ? Input[K] & IsNullable : Input[K] extends SelectionRecord ? MarkFieldsAsNullable<Input[K], TableName> : Input[K];
}>;
export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
    leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    crossJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
    fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
}
export declare function querySelection({ select, from }: SelectQuery): Selection;
export declare function selectQuery(query: SelectQuery): Sql;
export declare class Union<Result, Meta extends QueryMeta = QueryMeta> extends UnionBase<Result, Meta> implements HasSelection {
    readonly [internalData]: QueryData<Meta> & UnionQuery;
    constructor(data: QueryData<Meta> & UnionQuery);
    get [internalQuery](): Sql;
    get [internalSelection](): Selection;
    orderBy(...orderBy: Array<HasSql>): Union<Result, Meta>;
    limit(limit: UserInput<number>): Union<Result, Meta>;
    offset(offset: UserInput<number>): Union<Result, Meta>;
}
export declare function union<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
export declare function unionAll<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
export declare function intersect<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
export declare function intersectAll<Result, Meta extends IsPostgres | IsMysql>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
export declare function except<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
export declare function exceptAll<Result, Meta extends IsPostgres | IsMysql>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
export declare function unionQuery(query: UnionQuery): Sql;
export {};