import { ColumnsSelection, DrizzleTypeError, entityKind, ExtractTablesWithRelations, RelationalSchemaConfig, SQLWrapper, TablesRelationalConfig, WithSubquery } from "drizzle-orm";
import { AnyPgColumn, AnyPgTable, PgDialect, PgMaterializedView, PgTransactionConfig, QueryResultHKT, QueryResultKind, SelectedFields, WithSubqueryWithSelection } from "drizzle-orm/pg-core";
import { PgTExtensionManager } from "./extensions.js";
import { PgTDelete } from "./query-builders/delete.js";
import { PgTInsertBuilder } from "./query-builders/insert.js";
import { PgTRelationalQueryBuilder } from "./query-builders/query.js";
import { PgTQueryBuilder, TypedQueryBuilder } from "./query-builders/query-builder.js";
import { PgTRefreshMaterializedView } from "./query-builders/refresh-materialized-view.js";
import { PgTSelectBuilder } from "./query-builders/select.js";
import { PgTransaction } from "./query-builders/transaction.js";
import { PgTUpdateBuilder } from "./query-builders/update.js";
import { PgTSession } from "./session.js";
export declare class PgTDatabase<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
    /** @internal */
    readonly dialect: PgDialect;
    /** @internal */
    readonly session: PgTSession<TFullSchema, TSchema>;
    static readonly [entityKind]: string;
    readonly _: {
        readonly schema: TSchema | undefined;
        readonly tableNamesMap: Record<string, string>;
    };
    query: TFullSchema extends Record<string, never> ? DrizzleTypeError<"Seems like the schema generic is missing - did you forget to add it to your DB type?"> : {
        [K in keyof TSchema]: PgTRelationalQueryBuilder<TSchema, TSchema[K]>;
    };
    constructor(
    /** @internal */
    dialect: PgDialect, 
    /** @internal */
    session: PgTSession<TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined);
    $with<TAlias extends string>(alias: TAlias): {
        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection, unknown> | ((qb: PgTQueryBuilder) => TypedQueryBuilder<TSelection, unknown>)): WithSubqueryWithSelection<TSelection, TAlias>;
    };
    with(...queries: WithSubquery[]): {
        select: {
            (): PgTSelectBuilder<undefined>;
            <TSelection extends SelectedFields>(fields: TSelection): PgTSelectBuilder<TSelection, "db">;
        };
    };
    select(): PgTSelectBuilder<undefined>;
    select<TSelection extends SelectedFields>(fields: TSelection): PgTSelectBuilder<TSelection>;
    selectDistinct(): PgTSelectBuilder<undefined>;
    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgTSelectBuilder<TSelection>;
    selectDistinctOn(on: (AnyPgColumn | SQLWrapper)[]): PgTSelectBuilder<undefined>;
    selectDistinctOn<TSelection extends SelectedFields>(on: (AnyPgColumn | SQLWrapper)[], fields: TSelection): PgTSelectBuilder<TSelection>;
    update<TTable extends AnyPgTable>(table: TTable): PgTUpdateBuilder<TTable, TQueryResult>;
    insert<TTable extends AnyPgTable>(table: TTable): PgTInsertBuilder<TTable, TQueryResult>;
    delete<TTable extends AnyPgTable>(table: TTable): PgTDelete<TTable, TQueryResult>;
    refreshMaterializedView<TView extends PgMaterializedView>(view: TView): PgTRefreshMaterializedView<TQueryResult>;
    execute<TRow extends Record<string, unknown> = Record<string, unknown>>(query: SQLWrapper): Promise<QueryResultKind<TQueryResult, TRow>>;
    transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
    get extensions(): PgTExtensionManager;
    /**
     * Connects to the database and initializes the extensions.
     */
    connect(): Promise<void>;
}