import { DuckDBInstance } from '@duckdb/node-api';
import { entityKind } from 'drizzle-orm/entity';
import type { Logger } from 'drizzle-orm/logger';
import { PgDatabase } from 'drizzle-orm/pg-core/db';
import type { PgSelectBuilder, SelectedFields } from 'drizzle-orm/pg-core/query-builders';
import type { PgColumn, PgTransactionConfig } from 'drizzle-orm/pg-core';
import { type ExtractTablesWithRelations, type RelationalSchemaConfig, type TablesRelationalConfig } from 'drizzle-orm/relations';
import { type DrizzleConfig } from 'drizzle-orm/utils';
import type { SQL, SQLWrapper } from 'drizzle-orm/sql/sql';
import type { WithSubquery } from 'drizzle-orm/subquery';
import type { DuckDBClientLike, DuckDBQueryResultHKT, DuckDBTransaction } from './session.ts';
import { DuckDBSession } from './session.ts';
import { DuckDBDialect } from './dialect.ts';
import { type DuckDBSelectBuilder } from './select-builder.ts';
import type { ExecuteBatchesRawChunk, ExecuteInBatchesOptions, RowData } from './client.ts';
import { type DuckDBPoolConfig, type PoolPreset } from './pool.ts';
import { type PreparedStatementCacheConfig, type PrepareCacheOption } from './options.ts';
import { type DuckLakeConfig } from './ducklake.ts';
export interface PgDriverOptions {
    decimalMode?: 'number' | 'string';
    logger?: Logger;
    rejectStringArrayLiterals?: boolean;
    arrayLiteralWarning?: (query: string) => void;
    prepareCache?: PreparedStatementCacheConfig;
}
export declare class DuckDBDriver {
    private client;
    private dialect;
    private options;
    static readonly [entityKind]: string;
    constructor(client: DuckDBClientLike, dialect: DuckDBDialect, options?: PgDriverOptions);
    createSession(schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined): DuckDBSession<Record<string, unknown>, TablesRelationalConfig>;
}
/** Connection configuration when using path-based connection */
export interface DuckDBConnectionConfig {
    /** Database path: ':memory:', './file.duckdb', 'md:', 'md:database' */
    path: string;
    /** DuckDB instance options (e.g., motherduck_token) */
    options?: Record<string, string>;
}
export interface DuckDBDrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> extends DrizzleConfig<TSchema> {
    rejectStringArrayLiterals?: boolean;
    arrayLiteralWarning?: (query: string) => void;
    prepareCache?: PrepareCacheOption;
    /** Opt into legacy heuristic qualification of raw SQL join operands. */
    qualifyRawJoinColumns?: boolean;
    /** Opt into exact DECIMAL strings across execution paths. */
    decimalMode?: 'number' | 'string';
    /** Pool configuration. Use preset name, size config, or false to disable. */
    pool?: DuckDBPoolConfig | PoolPreset | false;
    /** Optional DuckLake configuration */
    ducklake?: DuckLakeConfig;
}
export interface DuckDBDrizzleConfigWithConnection<TSchema extends Record<string, unknown> = Record<string, never>> extends DuckDBDrizzleConfig<TSchema> {
    /** Connection string or config object */
    connection: string | DuckDBConnectionConfig;
}
export interface DuckDBDrizzleConfigWithClient<TSchema extends Record<string, unknown> = Record<string, never>> extends DuckDBDrizzleConfig<TSchema> {
    /** Explicit client (connection or pool) */
    client: DuckDBClientLike;
}
export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(connectionString: string): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(connectionString: string, config: DuckDBDrizzleConfig<TSchema>): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DuckDBDrizzleConfigWithConnection<TSchema>): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DuckDBDrizzleConfigWithClient<TSchema>): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: DuckDBClientLike, config?: DuckDBDrizzleConfig<TSchema>): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
export declare class DuckDBDatabase<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> extends PgDatabase<DuckDBQueryResultHKT, TFullSchema, TSchema> {
    readonly dialect: DuckDBDialect;
    readonly session: DuckDBSession<TFullSchema, TSchema>;
    static readonly [entityKind]: string;
    /** The underlying connection or pool */
    readonly $client: DuckDBClientLike;
    /** The DuckDB instance (when created from connection string) */
    readonly $instance?: DuckDBInstance;
    constructor(dialect: DuckDBDialect, session: DuckDBSession<TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined, client: DuckDBClientLike, instance?: DuckDBInstance);
    /**
     * Close the database connection pool and instance.
     * Should be called when shutting down the application.
     */
    close(): Promise<void>;
    private selectMethods;
    with(...queries: WithSubquery[]): ReturnType<PgDatabase<DuckDBQueryResultHKT, TFullSchema, TSchema>['with']>;
    select(): DuckDBSelectBuilder<undefined>;
    select<TSelection extends SelectedFields>(fields: TSelection): DuckDBSelectBuilder<TSelection>;
    selectDistinct(): PgSelectBuilder<undefined>;
    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
    selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
    selectDistinctOn<TSelection extends SelectedFields>(on: (PgColumn | SQLWrapper)[], fields: TSelection): PgSelectBuilder<TSelection>;
    executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<T[], void, void>;
    executeBatchesRaw(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<ExecuteBatchesRawChunk, void, void>;
    executeArrow(query: SQL): Promise<unknown>;
    /**
     * Run a transaction. The `config` argument is deprecated: DuckDB has no
     * SET TRANSACTION statement, so it is ignored with a one-time warning.
     */
    transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
}