import { type SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
import type { Database } from 'bun:sqlite';
import type { AnyRelations, EmptyRelations } from 'drizzle-orm';
import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
export type SqlStatementMetadata = {
    table: string;
    publicTable: string;
    kind: 'delete' | 'insert' | 'update' | 'upsert';
};
export type SQLiteQueryFormat = {
    relationships: Record<string, SQLiteQueryFormat>;
    singular: boolean;
};
export type SQLiteExecResult = {
    changes: number;
};
export type SQLiteStatement = {
    sql: string;
    params?: readonly unknown[];
    metadata?: SqlStatementMetadata;
};
export type SQLiteTransactionExecutor = {
    exec(sql: string, params?: readonly unknown[], metadata?: SqlStatementMetadata): SQLiteExecResult | Promise<SQLiteExecResult>;
    /**
     * every statement in one call to the storage owner, in order, as one
     * atomic step. a remote owner holds its writer across each round trip, so a
     * list sent one statement at a time holds it for the whole exchange.
     */
    execMany(statements: readonly SQLiteStatement[]): SQLiteExecResult[] | Promise<SQLiteExecResult[]>;
    query<Row extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Row[] | Promise<Row[]>;
    queryAst<Result = unknown>(ast: unknown, format: SQLiteQueryFormat, queryName?: string): Result | Promise<Result>;
};
export type SQLiteTransactionProvider = <Value>(work: (executor: SQLiteTransactionExecutor) => Value | Promise<Value>) => Promise<Value>;
export type SQLiteSchema = Record<string, SQLiteTable>;
export type CreateSQLiteDatabaseOptions<TSchema extends SQLiteSchema, TRelations extends AnyRelations = EmptyRelations> = {
    schema: TSchema;
    relations?: TRelations;
    transactionProvider: SQLiteTransactionProvider;
};
export type SQLiteDatabaseTransaction<TSchema extends SQLiteSchema, TRelations extends AnyRelations> = {
    executor: SQLiteTransactionExecutor;
    drizzle: SqliteRemoteDatabase<TSchema, TRelations>;
};
export type SQLiteDatabase<TSchema extends SQLiteSchema, TRelations extends AnyRelations> = {
    transaction<Value>(work: (transaction: SQLiteDatabaseTransaction<TSchema, TRelations>) => Value | Promise<Value>): Promise<Value>;
};
/**
 * Creates Drizzle only after the storage owner has started its transaction.
 * The sqlite-proxy driver is used solely to turn its query callbacks into
 * typed Drizzle operations; it never owns BEGIN or COMMIT.
 */
export declare function createSQLiteDatabase<TSchema extends SQLiteSchema, TRelations extends AnyRelations = EmptyRelations>(options: CreateSQLiteDatabaseOptions<TSchema, TRelations>): SQLiteDatabase<TSchema, TRelations>;
export declare function createSQLiteDrizzle<TSchema extends SQLiteSchema, TRelations extends AnyRelations = EmptyRelations>(executor: SQLiteTransactionExecutor, options: Pick<CreateSQLiteDatabaseOptions<TSchema, TRelations>, 'relations' | 'schema'>): SqliteRemoteDatabase<TSchema, TRelations>;
export type CreateBunSQLiteExecutorOptions = {
    database: Database;
    queryAst<Result = unknown>(ast: unknown, format: SQLiteQueryFormat, queryName?: string): Result | Promise<Result>;
    safeIntegers?: boolean;
};
export declare function createBunSQLiteExecutor({ database, queryAst, safeIntegers, }: CreateBunSQLiteExecutorOptions): SQLiteTransactionExecutor;
export type CreateBunSQLiteTransactionProviderOptions = CreateBunSQLiteExecutorOptions;
/**
 * Bun's synchronous driver needs its own native transaction boundary. Remote
 * and Durable Object hosts pass their protected callback directly to
 * createSQLiteDatabase instead.
 */
export declare function createBunSQLiteTransactionProvider({ database, queryAst, safeIntegers, }: CreateBunSQLiteTransactionProviderOptions): SQLiteTransactionProvider;
//# sourceMappingURL=sqlite.d.ts.map