import type { Adapter, ColumnTypes, Functions } from '@kubun/db-adapter';
import { type Logger } from '@kubun/logger';
import { Kysely } from 'kysely';
import { type Migration } from 'kysely/migration';
export type MigrationContext = {
    types: ColumnTypes;
    functions: Functions;
};
export type StoreDefinition<Tables, API> = {
    name: string;
    migrations: Record<string, Migration> | ((ctx: MigrationContext) => Record<string, Migration>);
    dependsOn?: Array<string>;
    createAPI: (db: Kysely<Tables>, adapter: Adapter) => API;
};
export type StoreProvider<Stores extends Record<string, unknown> = Record<string, unknown>> = {
    getStore<S extends keyof Stores & string>(name: S): Promise<Stores[S]>;
    onCommit(fn: () => void): void;
    /**
     * Run `fn` against a `StoreProvider` that scopes its writes to a transaction.
     *
     * On `KubunDB`, opens a fresh DB transaction and provides a transactional
     * `tx` provider; the outer provider's `onCommit` hooks fire after commit.
     *
     * On a transactional `tx` provider obtained from a parent
     * `withTransaction` call, this method runs `fn` inline with `this` as the
     * nested `tx`. The underlying driver does not nest transactions
     * (no savepoints), so atomicity is inherited from the outer transaction
     * — a throw in `fn` rolls the whole outer transaction back, exactly the
     * semantics callers expect for "register + bind atomically".
     */
    withTransaction<NestedStores extends Record<string, unknown>, R>(fn: (tx: StoreProvider<NestedStores>) => Promise<R>): Promise<R>;
};
export type KubunDBParams = {
    adapter: Adapter;
    logger?: Logger;
};
export declare class KubunDB implements StoreProvider {
    #private;
    constructor(params: KubunDBParams);
    get adapter(): Adapter;
    register<Tables, API>(store: StoreDefinition<Tables, API>): void;
    getStore<T>(name: string): Promise<T>;
    onCommit(fn: () => void): void;
    /**
     * Runs `fn` inside a DB transaction and provides a scoped `StoreProvider`.
     * Concurrent calls on the same `KubunDB` instance are supported — the
     * underlying driver serializes them.
     *
     * Callers MUST use the provided `tx` inside the callback. Calling
     * `db.withTransaction` on the same instance inside the callback opens a
     * new independent transaction (no atomic nesting) and is a bug.
     */
    withTransaction<Stores extends Record<string, unknown>, R>(fn: (tx: StoreProvider<Stores>) => Promise<R>): Promise<R>;
    close(): Promise<void>;
}