import { entityKind } from 'drizzle-orm/entity';
import type { Logger } from 'drizzle-orm/logger';
import { PgTransaction } from 'drizzle-orm/pg-core';
import type { PgColumn } from 'drizzle-orm/pg-core';
import type { PgSelectBuilder, SelectedFields } from 'drizzle-orm/pg-core/query-builders';
import type { SelectedFieldsOrdered } from 'drizzle-orm/pg-core/query-builders/select.types';
import type { PgTransactionConfig, PreparedQueryConfig, PgQueryResultHKT } from 'drizzle-orm/pg-core/session';
import { PgPreparedQuery, PgSession } from 'drizzle-orm/pg-core/session';
import type { RelationalSchemaConfig, TablesRelationalConfig } from 'drizzle-orm/relations';
import { type Query, SQL, type SQLWrapper } from 'drizzle-orm/sql/sql';
import type { WithSubquery } from 'drizzle-orm/subquery';
import type { Assume } from 'drizzle-orm/utils';
import type { DuckDBDialect } from './dialect.ts';
import type { DuckDBClientLike, RowData } from './client.ts';
import { type ExecuteBatchesRawChunk, type ExecuteInBatchesOptions } from './client.ts';
import type { PreparedStatementCacheConfig } from './options.ts';
import { type DuckDBSelectBuilder } from './select-builder.ts';
export type { DuckDBClientLike, RowData } from './client.ts';
type QueryMetadata = {
    type: 'select' | 'update' | 'delete' | 'insert';
    tables: string[];
};
type CacheConfig = {
    enable?: boolean;
    autoInvalidate?: boolean;
    tag?: string;
    config?: unknown;
};
export declare class DuckDBPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
    private client;
    private dialect;
    private queryString;
    private params;
    private logger;
    private fields;
    private _isResponseInArrayMode;
    private customResultMapper;
    private rejectStringArrayLiterals;
    private prepareCache;
    private warnOnStringArrayLiteral?;
    private scalarParamIndexes?;
    private onStatementError?;
    private decimalMode;
    static readonly [entityKind]: string;
    private resultMapper?;
    constructor(client: DuckDBClientLike, dialect: DuckDBDialect, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined, rejectStringArrayLiterals: boolean, prepareCache: PreparedStatementCacheConfig | undefined, queryMetadata?: QueryMetadata, cacheConfig?: CacheConfig, warnOnStringArrayLiteral?: ((sql: string) => void) | undefined, scalarParamIndexes?: ReadonlySet<number> | undefined, onStatementError?: ((error: unknown) => void) | undefined, decimalMode?: 'number' | 'string');
    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
    private executeQuery;
    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
    isResponseInArrayMode(): boolean;
}
export interface DuckDBSessionOptions {
    decimalMode?: 'number' | 'string';
    logger?: Logger;
    rejectStringArrayLiterals?: boolean;
    arrayLiteralWarning?: (query: string) => void;
    prepareCache?: PreparedStatementCacheConfig;
}
export declare class DuckDBSession<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgSession<DuckDBQueryResultHKT, TFullSchema, TSchema> {
    private client;
    private schema;
    private options;
    static readonly [entityKind]: string;
    protected dialect: DuckDBDialect;
    private logger;
    private rejectStringArrayLiterals;
    private prepareCache;
    private hasWarnedArrayLiteral;
    private rollbackOnly;
    private statementFailures;
    constructor(client: DuckDBClientLike, dialect: DuckDBDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: DuckDBSessionOptions);
    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][]) => T['execute'], queryMetadata?: QueryMetadata, cacheConfig?: CacheConfig): PgPreparedQuery<T>;
    transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
    private warnOnStringArrayLiteral;
    private recordStatementFailure;
    /**
     * DuckDB keeps parser and binder failures recoverable but aborts the
     * transaction on execution failures. COMMIT then succeeds without saving
     * anything, so probe the transaction before committing.
     */
    private assertTransactionNotAborted;
    private rollbackQuietly;
    private prepareQueryExecution;
    private trackStreamFailures;
    executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
    executeBatchesRaw(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<ExecuteBatchesRawChunk, void, void>;
    executeArrow(query: SQL): Promise<unknown>;
    markRollbackOnly(): void;
    isRollbackOnly(): boolean;
}
export declare class DuckDBTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<DuckDBQueryResultHKT, TFullSchema, TSchema> {
    static readonly [entityKind]: string;
    constructor(dialect: DuckDBDialect, session: DuckDBSession<TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined, nestedIndex?: number);
    private getInternals;
    private markRollbackOnly;
    private selectMethods;
    with(...queries: WithSubquery[]): ReturnType<PgTransaction<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>;
    rollback(): never;
    /**
     * @deprecated DuckDB has no SET TRANSACTION statement, so transaction config
     * is ignored. This helper will be removed in the next major version.
     */
    getTransactionConfigSQL(config: PgTransactionConfig): SQL;
    /**
     * @deprecated DuckDB has no SET TRANSACTION statement. This method is a
     * no-op that warns once, and passing config will throw in the next major
     * version.
     */
    setTransaction(config: PgTransactionConfig): Promise<void>;
    executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
    executeBatchesRaw(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<ExecuteBatchesRawChunk, void, void>;
    executeArrow(query: SQL): Promise<unknown>;
    transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
    private runNestedWithoutSavepoint;
}
export type GenericRowData<T extends RowData = RowData> = T;
export type GenericTableData<T = RowData> = T[];
export interface DuckDBQueryResultHKT extends PgQueryResultHKT {
    type: GenericTableData<Assume<this['row'], RowData>>;
}