import { type HasQuery, type HasResolver, type HasSql, internalData, internalQuery } from './Internal.js';
import type { Deliver, QueryMeta } from './MetaData.js';
import type { PreparedStatement, Resolver } from './Resolver.js';
import type { Sql } from './Sql.js';
export declare class QueryData<Meta extends QueryMeta> {
    resolver?: Resolver<Meta>;
    first?: boolean;
}
type Exec = Function;
declare class Executable<Result, Meta extends QueryMeta> implements PromiseLike<Result> {
    #private;
    private brand;
    constructor(exec: Exec);
    [Symbol.iterator](): Generator<Promise<unknown>, Result, unknown>;
    run(): Deliver<Meta, void>;
    then<TResult1 = Result, TResult2 = never>(onfulfilled?: ((value: Result) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<Result | TResult>;
    finally(onfinally?: (() => void) | undefined | null): Promise<Result>;
}
export declare class BatchQuery<Results, Meta extends QueryMeta> extends Executable<Array<Results>, Meta> {
    constructor(queryResolver: Resolver, queries: Array<HasSql | HasQuery>);
}
export declare abstract class SingleQuery<Result, Meta extends QueryMeta> extends Executable<Result, Meta> {
    #private;
    readonly [internalData]: QueryData<Meta>;
    abstract [internalQuery]: Sql;
    constructor(data: QueryData<Meta>);
    all<Result extends Array<unknown>>(this: SingleQuery<Result, Meta>, db?: HasResolver): Deliver<Meta, Result>;
    get<Result extends Array<unknown>>(this: SingleQuery<Result, Meta>, db?: HasResolver): Deliver<Meta, Result[number] | null>;
    get(db?: HasResolver): Deliver<Meta, Result | null>;
    run(db?: HasResolver): Deliver<Meta, void>;
    prepare<Inputs extends Record<string, unknown>>(name?: string): PreparedQuery<Result, Inputs, Meta>;
    toSQL(db?: HasResolver): {
        sql: string;
        params: Array<unknown>;
    };
}
export interface PreparedQuery<Result, Inputs extends Record<string, unknown>, Meta extends QueryMeta> extends PreparedStatement<Meta> {
    all<Result extends Array<unknown>>(this: PreparedQuery<Result, Inputs, Meta>, inputs?: Inputs): Deliver<Meta, Result>;
    get(inputs?: Inputs): Deliver<Meta, Result>;
    get<Result extends Array<unknown>>(this: PreparedQuery<Result, Inputs, Meta>, inputs?: Inputs): Deliver<Meta, Result[number] | null>;
    run(inputs?: Inputs): Deliver<Meta, void>;
    execute(inputs?: Inputs): Promise<Result>;
    free(): void;
}
export {};