import type { Dialect } from './dialect.js';
import { Model } from './model.js';
import { Definition, QueryParams, AlterDefinition, Condition, BuildQueryResult, TransactionOptions, TransactionContext } from '../types.js';
import * as QueryClasses from './query-classes.js';
/**
 * 查询日志处理器类型
 */
export type QueryLogger = (info: {
    sql: string;
    params?: any[];
    duration: number;
    error?: Error;
}) => void;
/**
 * 基础数据库抽象类
 * 定义所有数据库类型的通用接口和行为
 */
export declare abstract class Database<D = any, S extends Record<string, object> = Record<string, object>, Q = string> {
    readonly dialect: Dialect<D, S, Q>;
    protected hasStarted: boolean;
    readonly definitions: Database.Definitions<S>;
    readonly models: Database.Models<S, D, Q>;
    private _logger?;
    private _logging;
    constructor(dialect: Dialect<D, S, Q>, definitions?: Database.DefinitionObj<S>);
    /**
     * 启用查询日志
     * @param handler 自定义日志处理器，不传则使用默认控制台输出
     */
    enableLogging(handler?: QueryLogger): this;
    /**
     * 禁用查询日志
     */
    disableLogging(): this;
    /**
     * 查询日志是否启用
     */
    get isLogging(): boolean;
    /**
     * 记录查询日志
     */
    protected log(sql: string, params?: any[], duration?: number, error?: Error): void;
    /**
     * 数据库是否已启动
     */
    get isStarted(): boolean;
    /**
     * 启动数据库
     */
    start(): Promise<void>;
    /**
     * 停止数据库
     */
    stop(): Promise<void>;
    /**
     * 健康检查
     */
    healthCheck(): Promise<boolean>;
    /**
     * 执行原生查询
     */
    query<U = any>(sql: Q, params?: any[]): Promise<U>;
    abstract buildQuery<T extends keyof S>(params: QueryParams<S, T>): BuildQueryResult<Q>;
    /**
     * 获取数据库方言名称
     */
    get dialectName(): string;
    /**
     * 获取数据库配置
     */
    get config(): any;
    /**
     * 抽象方法：初始化数据库
     */
    protected abstract initialize(): Promise<void>;
    define<K extends keyof S>(name: K, definition: Definition<S[K]>): void;
    /**
     * 删除表定义
     */
    destroy<K extends keyof S>(name: K): void;
    /**
     * 创建表
     */
    create<T extends keyof S>(name: T, definition: Definition<S[T]>): QueryClasses.Creation<S, T, D, Q>;
    alter<T extends keyof S>(name: T, alterations: AlterDefinition<S[T]>): QueryClasses.Alteration<S, T, D, Q>;
    select<T extends keyof S, K extends keyof S[T]>(name: T, fields: Array<K>): QueryClasses.Selection<S, T, K, D, Q>;
    insert<T extends keyof S>(name: T, data: S[T]): QueryClasses.Insertion<S, T, D, Q>;
    update<T extends keyof S>(name: T, update: Partial<S[T]>): QueryClasses.Updation<S, T, D, Q>;
    delete<T extends keyof S>(name: T, condition: Condition<S[T]>): QueryClasses.Deletion<S, T, D, Q>;
    /**
     * 批量插入
     */
    insertMany<T extends keyof S>(name: T, data: S[T][]): QueryClasses.BatchInsertion<S, T, D, Q>;
    /**
     * 聚合查询
     */
    aggregate<T extends keyof S>(name: T): QueryClasses.Aggregation<S, T, D, Q>;
    /**
     * 是否支持事务
     */
    supportsTransactions(): boolean;
    /**
     * 在事务中执行操作
     * 自动处理 commit 和 rollback
     * 支持链式调用：trx.insert(), trx.select(), trx.update(), trx.delete()
     */
    transaction<R>(callback: (trx: TransactionContext<S>) => Promise<R>, options?: TransactionOptions): Promise<R>;
    /**
     * 抽象方法：获取所有模型名称
     */
    abstract getModelNames(): string[];
    /**
     * 抽象方法：清理资源
     */
    dispose(): Promise<void>;
}
export declare namespace Database {
    class Definitions<S extends Record<string, object>> extends Map<keyof S, Definition<S[keyof S]>> {
        constructor();
    }
    class Models<S extends Record<string, object>, D = any, Q = string> extends Map<keyof S, Model<D, S, Q, keyof S>> {
        constructor();
        get<K extends keyof S>(key: K): Model<D, S, Q, K> | undefined;
    }
    type DefinitionObj<S extends Record<string, object>> = {
        [K in keyof S]: Definition<S[K]>;
    };
}
//# sourceMappingURL=database.d.ts.map