interface AriaEngineConfig {
    /** 页面大小（默认 4096） */
    pageSize?: number;
    /** Buffer Pool 页面数量（默认 256） */
    bufferPoolPages?: number;
    /** MemTable 刷盘阈值（默认 4MB） */
    memtableSizeThreshold?: number;
    /** LSM 层级之间的容量倍数（默认 10） */
    levelSizeMultiplier?: number;
    /** Bloom Filter 每 key 位数（默认 10） */
    bloomFilterBitsPerKey?: number;
    /** 是否启用 WAL（默认 true） */
    walEnabled?: boolean;
    /** WAL 同步模式 */
    walSyncMode?: 'full' | 'batch' | 'none';
    /** Checkpoint 间隔（操作数，默认 1000） */
    checkpointInterval?: number;
    /** 是否启用页面压缩（默认 false） */
    compression?: boolean;
    /** 存储后端 */
    storageBackend?: 'opfs' | 'memory' | 'kv';
    /** WAL 大小阈值（字节，超过则强制 checkpoint，默认 16MB） */
    walSizeThreshold?: number;
    /** 最大内存预算（MB，默认 64） */
    maxMemoryMB?: number;
    /**
     * v0.4.5: 全库 AES-256-GCM 加密（backend 层透明加解密，WAL/SSTable/Schema/元数据全覆盖）。
     * 密钥由 PBKDF2（salt 持久化于库内 __aria_keymeta）派生，重启用同一密码即可解密。
     */
    encryption?: {
        /** 加密密码 */
        password: string;
    };
    /**
     * v0.4.5: SSTable 页面化存储（4KB 页面 + BufferPool/FileManager 管理，LRU 缓存）。
     * 默认：storageBackend === 'opfs' 时自动启用（大文件随机读/写放大优化）；
     * 显式 false 强制关闭（整 value 存储，兼容旧行为）。
     */
    pageStorage?: boolean;
}

/**
 * metona-sqlark Constants — 类型定义 / 默认配置 / 枚举
 * @module constants
 */
/** 存储模式 */
type StorageMode = 'memory' | 'disk' | 'hybrid' | 'aria';
/** 磁盘引擎类型（v0.6.0: IndexedDB 已移除；'memory' 供 aria 内存后端；'kv' 供 aria 自研 KVStore 后端） */
type DiskEngine = 'opfs' | 'memory' | 'kv';
/** 字段数据类型 */
type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'json';
/** 列定义 */
interface ColumnDef {
    /** 字段类型 */
    type: FieldType;
    /** 是否主键 */
    primaryKey?: boolean;
    /** 是否必填 */
    required?: boolean;
    /** 是否唯一 */
    unique?: boolean;
    /** 默认值 */
    default?: unknown;
    /** 是否创建索引 */
    index?: boolean;
    /** 外键引用: 'table.column' */
    references?: string;
    /** 删除级联: 'CASCADE' | 'SET NULL' | 'RESTRICT' */
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
    /** 更新级联: 'CASCADE' | 'SET NULL' | 'RESTRICT' */
    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
    /** 字符串最大长度 */
    maxLength?: number;
    /** 数字最小值 */
    min?: number;
    /** 数字最大值 */
    max?: number;
}
/** 表结构定义 */
interface TableSchema {
    /** 表名 */
    name: string;
    /** 列定义映射 */
    columns: Record<string, ColumnDef>;
}
/** 数据库配置 */
interface DatabaseConfig {
    /** 数据库名称 */
    name: string;
    /** 存储模式 */
    mode?: StorageMode;
    /** 磁盘引擎（仅 mode='disk'|'hybrid' 时生效） */
    diskEngine?: DiskEngine;
    /** 版本号 */
    version?: number;
    /** 插件列表 */
    plugins?: MetonaPlugin[];
    /** 数据库就绪回调 */
    onReady?: (db: unknown) => void;
    /** 错误回调 */
    onError?: (error: Error) => void;
    /** 查询结果行数上限（默认 0，0 表示不限制） */
    maxRowsPerQuery?: number;
    /** 调试模式（启用后输出详细操作日志） */
    debug?: boolean;
    /** 多标签页同步（v0.3.2）：BroadcastChannel 广播表变更，其他标签页自动刷新 */
    multiTabSync?: boolean;
    /**
     * v0.4.5: AriaEngine 专属配置（mode='aria' 时透传）：
     * walSyncMode / checkpointInterval / encryption / pageStorage / compression 等
     */
    aria?: AriaEngineConfig;
}
/** Where 条件操作符 */
type WhereOperator = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$like' | '$and' | '$or' | '$not';
/** 简单条件值：直接相等 */
type SimpleCondition = unknown;
/** 操作符条件 */
type OperatorCondition = Partial<Record<WhereOperator, unknown>>;
/** 字段条件：简单值 | 操作符对象 */
type FieldCondition = SimpleCondition | OperatorCondition;
/** Where 条件对象 */
type WhereCondition = Record<string, FieldCondition>;
/** 排序方向 */
type SortDirection = 'asc' | 'desc';
/** 排序定义 */
interface OrderBy {
    /** 列名 */
    column: string;
    /** 排序方向 */
    direction: SortDirection;
    /** v0.4.0: NULL 值排序位置（first 排最前 / last 排最后，默认同引擎行为） */
    nulls?: 'first' | 'last';
}
/** 查询计划 — 由 Executor 编译 AST 后生成 */
interface QueryPlan {
    /** 表名 */
    table: string;
    /** 要返回的列（undefined = 全部，['*'] = 全部） */
    columns?: string[];
    /** 过滤条件 */
    where?: WhereCondition;
    /** 排序 */
    orderBy?: OrderBy[];
    /** 限制条数 */
    limit?: number;
    /** 偏移量 */
    offset?: number;
}
/** 钩子名称 */
type HookName = 'beforeCreateTable' | 'afterCreateTable' | 'beforeDropTable' | 'afterDropTable' | 'beforeInsert' | 'afterInsert' | 'beforeUpdate' | 'afterUpdate' | 'beforeDelete' | 'afterDelete' | 'beforeQuery' | 'afterQuery' | 'beforeTransaction' | 'afterTransaction';
/** 插件定义 */
interface MetonaPlugin {
    /** 插件名称 */
    name: string;
    /** 插件版本 */
    version: string;
    /** 描述 */
    description?: string;
    /** 优先级，越大越先执行 */
    priority?: number;
    /** 安装 */
    install(db: unknown): void;
    /** 销毁 */
    destroy(): void;
}
declare const VERSION = "0.8.0";

/**
 * metona-sqlark Plugin — 插件系统
 * @module plugin
 *
 * 管理插件的注册、生命周期和钩子调度。
 */

type HookCallback = (...args: unknown[]) => void | Promise<void>;
declare class PluginManager {
    private plugins;
    private hooks;
    /** 注册插件 */
    register(plugin: MetonaPlugin, db?: unknown): void;
    /** 卸载插件 */
    unregister(pluginName: string): void;
    /** 获取所有已注册插件 */
    getPlugins(): MetonaPlugin[];
    /** 添加钩子回调 */
    on(hook: HookName, callback: HookCallback): void;
    /** 移除钩子回调 */
    off(hook: HookName, callback: HookCallback): void;
    /** 触发钩子 */
    trigger(hook: HookName, ...args: unknown[]): Promise<void>;
    /** 销毁所有插件 */
    destroy(): void;
}

interface IStorageEngine {
    /** 引擎名称 */
    readonly name: string;
    /** 打开数据库 */
    open(dbName: string, version: number): Promise<void>;
    /** 关闭数据库 */
    close(): Promise<void>;
    /** 检查数据库是否已打开 */
    isOpen(): boolean;
    /** 创建表 */
    createTable(schema: TableSchema): Promise<void>;
    /** 删除表 */
    dropTable(tableName: string): Promise<void>;
    /** 检查表是否存在 */
    hasTable(tableName: string): Promise<boolean>;
    /** 获取所有表名 */
    getTableNames(): Promise<string[]>;
    /** 获取表结构 */
    getTableSchema(tableName: string): Promise<TableSchema | null>;
    /** 插入行，返回主键值列表 */
    insert(tableName: string, rows: Record<string, unknown>[]): Promise<string[]>;
    /** 查询行 */
    find(tableName: string, query: QueryPlan): Promise<Record<string, unknown>[]>;
    /** v0.4.0: 流式查询 — 逐行回调扫描（有 where/limit/projection，无 orderBy 语义；有 orderBy 时实现可回退物化） */
    findStream?(tableName: string, query: QueryPlan, onRow: (row: Record<string, unknown>) => void): Promise<number>;
    /** 更新行，返回影响行数 */
    update(tableName: string, query: QueryPlan, updates: Record<string, unknown>): Promise<number>;
    /** 删除行，返回影响行数 */
    delete(tableName: string, query: QueryPlan): Promise<number>;
    /** 计数 */
    count(tableName: string, query?: QueryPlan): Promise<number>;
    /** 清空表数据（保留结构） */
    clear(tableName: string): Promise<void>;
    /** v0.4.1: ALTER TABLE（可选）— 引擎级结构变更（Aria 需重写存储行，其余引擎走 Executor 通用路径） */
    alterTable?(tableName: string, action: 'ADD' | 'DROP', column: ColumnDef & {
        name: string;
    }): Promise<void>;
    /** 创建二级索引（CREATE INDEX） */
    createIndex?(tableName: string, column: string, unique?: boolean): Promise<void>;
    /** 删除二级索引（DROP INDEX） */
    dropIndex?(tableName: string, column: string, indexName?: string): Promise<void>;
    /** 开始事务 */
    beginTransaction(): Promise<void>;
    /** 提交事务 */
    commitTransaction(): Promise<void>;
    /** 回滚事务 */
    rollbackTransaction(): Promise<void>;
    /** 创建 Savepoint */
    savepoint?(name: string): Promise<void>;
    /** 回滚到 Savepoint */
    rollbackToSavepoint?(name: string): Promise<void>;
    /** 释放 Savepoint */
    releaseSavepoint?(name: string): Promise<void>;
    /** 在线备份：导出全库一致性快照 */
    backup?(): Promise<Record<string, Record<string, unknown>[]>>;
    /** 崩溃恢复自愈：校验并清理损坏数据、恢复一致性（检测到异常后调用，无需删库重建） */
    repair?(): Promise<void>;
    /** 清空全部数据与表结构（保留库本身，供演示页刷新/重建用） */
    clearAll?(): Promise<void>;
    /** 读取库内元数据（迁移版本持久化用） */
    getMeta?(key: string): Promise<string | null>;
    /** 写入库内元数据（迁移版本持久化用） */
    setMeta?(key: string, value: string): Promise<void>;
}

/**
 * metona-sqlark Query AST — 查询抽象语法树类型定义
 * @module query/ast
 *
 * QueryBuilder 和 SQL Parser 统一输出此 AST，
 * Executor 只认 AST，保证两种查询接口行为一致。
 */

/** 列引用，'*' 表示所有列；支持 'table.column' 格式 */
type ColumnRef = string;
/** JOIN 类型 */
type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'CROSS';
/** JOIN 子句 */
interface JoinClause {
    type: JoinType;
    table: string;
    alias?: string;
    on: WhereCondition;
}
interface ASTColumnDef {
    name: string;
    type: string;
    primaryKey?: boolean;
    unique?: boolean;
    required?: boolean;
    default?: unknown;
    index?: boolean;
    maxLength?: number;
    min?: number;
    max?: number;
    /** 外键引用 */
    references?: string;
    /** 级联删除 */
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
    /** 级联更新 */
    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
}
interface CreateTableStatement {
    type: 'CREATE_TABLE';
    name: string;
    columns: ASTColumnDef[];
    /** IF NOT EXISTS — 表已存在时不报错 */
    ifNotExists?: boolean;
}
interface DropTableStatement {
    type: 'DROP_TABLE';
    name: string;
    /** IF EXISTS — 表不存在时不报错 */
    ifExists?: boolean;
}
/** EXPLAIN 查询计划 */
interface ExplainStatement {
    type: 'EXPLAIN';
    query: Statement;
}
interface InsertStatement {
    type: 'INSERT';
    into: string;
    columns?: string[];
    /** VALUES 字面量 */
    values?: unknown[][];
    /** INSERT INTO ... SELECT ...（v0.3.0） */
    select?: SelectStatement | SelectUnionStatement;
}
interface UpdateStatement {
    type: 'UPDATE';
    table: string;
    sets: Record<string, unknown>;
    where: WhereCondition;
}
interface DeleteStatement {
    type: 'DELETE';
    from: string;
    where: WhereCondition;
}
interface SelectStatement {
    type: 'SELECT';
    columns: ColumnRef[];
    distinct?: boolean;
    from: string;
    /** v0.4.0: FROM (SELECT ...) 派生表（存在时 from 为占位，行源取此子查询结果） */
    fromSubquery?: SelectStatement | SelectUnionStatement;
    /** 主表别名 */
    alias?: string;
    /** JOIN 子句列表 */
    joins?: JoinClause[];
    where: WhereCondition;
    /** GROUP BY */
    groupBy?: string[];
    /** HAVING */
    having?: WhereCondition;
    orderBy?: OrderBy[];
    limit?: number;
    offset?: number;
}
interface SelectUnionStatement {
    type: 'SELECT_UNION';
    /** 左操作数（可以是 SELECT 或嵌套 UNION） */
    left: SelectStatement | SelectUnionStatement;
    /** 右操作数 */
    right: SelectStatement | SelectUnionStatement;
    /** UNION ALL 不去重 */
    all?: boolean;
}
interface AlterTableStatement {
    type: 'ALTER_TABLE';
    name: string;
    action: 'ADD' | 'DROP';
    column: ASTColumnDef;
}
interface TruncateTableStatement {
    type: 'TRUNCATE_TABLE';
    name: string;
}
interface CreateIndexStatement {
    type: 'CREATE_INDEX';
    /** 索引名（语法占位） */
    name: string;
    table: string;
    column: string;
    /** UNIQUE 索引 */
    unique?: boolean;
}
interface DropIndexStatement {
    type: 'DROP_INDEX';
    name: string;
    table: string;
    column: string;
}
interface BeginTransactionStatement {
    type: 'BEGIN';
}
interface CommitTransactionStatement {
    type: 'COMMIT';
}
interface RollbackTransactionStatement {
    type: 'ROLLBACK';
}
/** SAVEPOINT name / ROLLBACK TO SAVEPOINT name / RELEASE SAVEPOINT name */
interface SavepointStatement {
    type: 'SAVEPOINT';
    name: string;
    /** SAVE = 创建；ROLLBACK = 回滚到；RELEASE = 释放 */
    action: 'SAVE' | 'ROLLBACK' | 'RELEASE';
}
/** ANALYZE TABLE name — 收集表统计信息 */
interface AnalyzeStatement {
    type: 'ANALYZE';
    table: string;
}
/** REINDEX TABLE name — 重建表二级索引 */
interface ReindexStatement {
    type: 'REINDEX';
    table: string;
}
/** VACUUM — 压缩 LSM + 清理碎片 */
interface VacuumStatement {
    type: 'VACUUM';
}
type Statement = SelectStatement | SelectUnionStatement | ExplainStatement | InsertStatement | UpdateStatement | DeleteStatement | CreateTableStatement | DropTableStatement | AlterTableStatement | TruncateTableStatement | CreateIndexStatement | DropIndexStatement | BeginTransactionStatement | CommitTransactionStatement | RollbackTransactionStatement | SavepointStatement | AnalyzeStatement | ReindexStatement | VacuumStatement;

/**
 * metona-sqlark Query Executor — AST 执行器
 * @module query/executor
 *
 * JOIN / GROUP BY / DISTINCT 逻辑在此层处理。
 */

declare class QueryExecutor {
    private engine;
    private maxRowsPerQuery;
    constructor(engine: IStorageEngine, maxRowsPerQuery?: number);
    execute(stmt: Statement): Promise<unknown>;
    /** 递归执行 UNION / UNION ALL，返回合并结果 */
    private executeSelectUnion;
    private executeSelectPart;
    /** 将 UNION 右侧行投影为左侧列结构（按位置取值） */
    private projectUnionRow;
    /** EXPLAIN: 输出查询计划 */
    private executeExplain;
    private executeSelect;
    private executeJoinSelect;
    private prefixRow;
    /**
     * v0.4.1: 提取可下推的 WHERE 条件 — 主表别名前缀的普通条件（如 o.user_id = '1'）。
     * 下推到引擎可走二级索引；$col/$subquery/$and/$or/$not 等复杂条件保守不下推。
     */
    private extractPushableWhere;
    /**
     * 哈希连接（v0.3.2 单等值 / v0.4.0 多列等值）：
     * ON 为等值条件（单列或多列）且右表任一列为索引/主键时，
     * 收集左表连接值 → 一次 $in 查询右表 → 哈希映射匹配。
     * 替代嵌套循环，大表 INNER/LEFT JOIN 复杂度 O(N + M)。
     * 不适用时返回 null（回退嵌套循环）。
     */
    private tryHashJoin;
    /** 嵌套循环连接（优化：避免 ON 时对象扩散） */
    private joinRows;
    private executeGroupBy;
    private computeAggregate;
    private executeDistinct;
    private executeInsert;
    private executeUpdate;
    private executeDelete;
    /**
     * v0.7.4: 写语句（UPDATE/DELETE）WHERE 的子查询解析。
     * 非关联子查询（$subquery）解析为具体值列表/标量；
     * 关联引用（$col / 关联 EXISTS）在写语句中无法逐行绑定外层上下文
     * （引擎层 matchWhere 无 $col 绑定选项）→ 显式 NOT_SUPPORTED 而非静默 0 行。
     */
    private resolveWriteWhere;
    private executeCreateTable;
    private executeDropTable;
    private executeAlterTable;
    private executeTruncateTable;
    private executeCreateIndex;
    private executeDropIndex;
    private executeBegin;
    private executeCommit;
    private executeRollback;
    /** SAVEPOINT name / ROLLBACK TO SAVEPOINT name / RELEASE SAVEPOINT name */
    private executeSavepoint;
    /** ANALYZE TABLE name — 收集表统计信息 */
    private executeAnalyze;
    /** REINDEX TABLE name — 重建表二级索引 */
    private executeReindex;
    /** VACUUM — 压缩 LSM + 清理碎片 */
    private executeVacuum;
    /** 列列表是否包含 CASE WHEN 表达式 */
    private hasCaseColumn;
    /**
     * v0.3.3: ORDER BY 是否引用 SELECT 别名（如 `SELECT name AS n ... ORDER BY n`）。
     * 别名列在引擎层投影前不存在，需投影后重新排序。
     */
    private orderByUsesSelectAlias;
    /** WHERE 是否包含 CASE WHEN 表达式键 */
    private whereHasCase;
    getEngine(): IStorageEngine;
    /**
     * 列投影（v0.3.1）：普通列走 projectColumns，CASE WHEN 表达式逐行求值；
     * v0.3.3: 支持 `col AS alias` 列别名
     */
    private projectRow;
    /** 检查 SELECT 列列表中是否包含聚合函数 */
    private _hasAggregateColumn;
    /** 计算单行聚合结果（无 GROUP BY） */
    private computeSingleAggregate;
    /** 剥离主表别名前缀：'u.id' → 'id'（键与 $col 值均处理，支持多层别名） */
    private normalizeWhereColumns;
    private normalizeExistsValue;
    private normalizeFieldValue;
    private stripAlias;
    /** WHERE 是否含关联引用（$col 或关联 EXISTS）或 CASE WHEN 表达式键 */
    private hasCorrelatedRefs;
    private fieldHasColRef;
    /** 移除关联 EXISTS 标记（引擎层先执行无 EXISTS 条件的查询） */
    private stripCorrelatedExists;
    /** 逐行绑定外层行上下文，求值关联 EXISTS、$col 引用与 CASE WHEN 键 */
    private filterCorrelated;
    /** 将 WHERE 中的 CASE WHEN 表达式键求值为布尔条件（$caseResult） */
    private resolveCaseKeys;
    /** CASE 求值结果与操作符条件比较 */
    private caseConditionMatches;
    /** 将 where 中的 $col 引用替换为上下文行值 */
    private bindColumnRefs;
    private bindWhereRefs;
    /**
     * 递归扫描 WHERE 条件，找到 $subquery 标记并执行子查询，
     * 将结果替换为具体值。
     * @param contextRow 关联子查询的外层行上下文（用于绑定 $col 引用）
     */
    private resolveSubqueries;
    /**
     * 解析操作符值中嵌套的子查询
     */
    private resolveOperatorSubqueries;
}

declare class SelectQueryBuilder {
    private engine;
    private tableName;
    private _columns;
    private _where;
    private _orderBy;
    private _limit?;
    private _offset?;
    private _joins;
    private _alias?;
    private _executor?;
    constructor(engine: IStorageEngine, tableName: string, _columns?: string[], executor?: QueryExecutor);
    /** 主表别名 */
    as(alias: string): this;
    /** INNER JOIN */
    innerJoin(table: string, on: WhereCondition, alias?: string): this;
    /** LEFT JOIN */
    leftJoin(table: string, on: WhereCondition, alias?: string): this;
    /** RIGHT JOIN */
    rightJoin(table: string, on: WhereCondition, alias?: string): this;
    /** CROSS JOIN */
    crossJoin(table: string, alias?: string): this;
    /** 通用 JOIN */
    join(table: string, on: WhereCondition, alias?: string): this;
    private _addJoin;
    /** 添加过滤条件 */
    where(condition: WhereCondition): this;
    /** 排序 */
    orderBy(column: string, direction?: SortDirection): this;
    /** 限制返回条数 */
    limit(n: number): this;
    /** 偏移量 */
    offset(n: number): this;
    /** 执行查询 */
    execute(): Promise<Record<string, unknown>[]>;
    /** 获取 AST */
    toAST(): SelectStatement;
}
declare class UpdateQueryBuilder {
    private engine;
    private tableName;
    private _updates;
    private _where;
    private onWrite?;
    /** v0.5.1: CRUD hooks 触发回调 */
    private onHooks?;
    constructor(engine: IStorageEngine, tableName: string, _updates: Record<string, unknown>, onWrite?: (table: string) => void, onHooks?: (hook: HookName, args: unknown[]) => Promise<void>);
    where(condition: WhereCondition): this;
    execute(): Promise<number>;
    toAST(): UpdateStatement;
}
declare class DeleteQueryBuilder {
    private engine;
    private tableName;
    private _where;
    private onWrite?;
    /** v0.5.1: CRUD hooks 触发回调 */
    private onHooks?;
    constructor(engine: IStorageEngine, tableName: string, onWrite?: (table: string) => void, onHooks?: (hook: HookName, args: unknown[]) => Promise<void>);
    where(condition: WhereCondition): this;
    execute(): Promise<number>;
    toAST(): DeleteStatement;
}

declare class Table<T = Record<string, unknown>> {
    readonly name: string;
    private engine;
    private schema;
    private executor;
    /** 写入回调（多标签页广播，v0.3.2） */
    private onWrite?;
    /** v0.5.1: CRUD 生命周期钩子触发回调（beforeInsert/afterInsert/... 真实接线） */
    private onHooks?;
    constructor(engine: IStorageEngine, tableName: string, executor?: QueryExecutor, onWrite?: (table: string) => void, onHooks?: (hook: HookName, args: unknown[]) => Promise<void>);
    getSchema(): Promise<TableSchema>;
    insert(row: T & Record<string, unknown>): Promise<string>;
    insertMany(rows: (T & Record<string, unknown>)[]): Promise<string[]>;
    select(columns?: string[]): SelectQueryBuilder;
    /** v0.4.0: 流式查询 — 逐行回调，不物化全部结果 */
    stream(onRow: (row: T & Record<string, unknown>) => void, query?: {
        where?: Record<string, unknown>;
        limit?: number;
        offset?: number;
        columns?: string[];
    }): Promise<number>;
    update(updates: Partial<T> & Record<string, unknown>): UpdateQueryBuilder;
    delete(): DeleteQueryBuilder;
    count(where?: Record<string, unknown>): Promise<number>;
    clear(): Promise<void>;
    drop(): Promise<void>;
}

/**
 * metona-sqlark Transaction — 事务管理
 * @module transaction
 *
 * v0.1.13: 支持真正的回滚 — 利用引擎层 begin/commit/rollback 实现原子性。
 */

declare class Transaction {
    private engine;
    private tables;
    private completed;
    constructor(engine: IStorageEngine);
    /** 获取表操作对象 */
    table(tableName: string): Table;
    /** 标记事务完成（由 TransactionManager 调用） */
    _markCompleted(): void;
    /** 是否已完成 */
    isCompleted(): boolean;
}

declare class MetonaSqlark {
    /** 数据库名称 */
    readonly name: string;
    /**
     * v0.7.1: 静态工厂（与 connect/disconnect 同一入口风格）。
     * 此前 create 仅存在于 api 对象 / window 挂载 —— README/站点示例的
     * `MetonaSqlark.create({...})` 在 ESM/Node 下是 undefined（TypeError）。
     */
    static create(config: DatabaseConfig): Promise<MetonaSqlark>;
    /** 存储模式 */
    readonly mode: string;
    /** 版本号 */
    private _version;
    /** 获取版本号 */
    get version(): number;
    private engine;
    private executor;
    private transactionManager;
    private pluginManager;
    private config;
    private ready;
    private tableCache;
    /** 查询结果行数上限 */
    get maxRowsPerQuery(): number;
    /** 调试模式 */
    get debug(): boolean;
    /** 多标签页同步通道（v0.3.2） */
    private channel;
    constructor(config: DatabaseConfig);
    /** 初始化数据库（创建引擎、打开连接） */
    init(): Promise<void>;
    /** 检查是否就绪 */
    isReady(): boolean;
    /** 创建表 */
    defineTable(name: string, columns: Record<string, ColumnDef>): Promise<void>;
    /** 获取表操作对象 */
    table(name: string): Table;
    /** 删除表 */
    dropTable(name: string): Promise<void>;
    /** 获取所有表名 */
    getTableNames(): Promise<string[]>;
    /**
     * 执行 SQL 字符串查询。
     * v0.7.0: 支持位置参数（`?`）—— `db.query('SELECT * FROM t WHERE id = ?', ['1'])`。
     * 参数按 SQL 字面量安全编码（字符串 '' 转义），杜绝 SQL 注入。
     */
    query(sql: string, params?: unknown[]): Promise<unknown>;
    /**
     * 流式查询：逐行回调，不一次性物化全部结果（大表友好）。
     * 支持简单 SELECT（WHERE/LIMIT/OFFSET/列投影）；
     * JOIN/GROUP BY/UNION/聚合/ORDER BY 自动回退为物化查询后逐行回调。
     *
     * @example
     * ```ts
     * let total = 0;
     * await db.queryStream('SELECT * FROM logs WHERE level = \'error\'', (row) => {
     *   total++;
     *   processRow(row);
     * });
     * ```
     */
    queryStream<T extends Record<string, unknown> = Record<string, unknown>>(sql: string, onRow: (row: T) => void): Promise<number>;
    /** 流式查询用：剥离主表别名前缀（复用 query 路径的规范化逻辑） */
    private normalizeWhereForStream;
    /** 执行事务 */
    transaction<T>(fn: (trx: Transaction) => Promise<T>): Promise<T>;
    /** 导出表数据为 JSON */
    exportTable(tableName: string): Promise<Record<string, unknown>[]>;
    /** 导入 JSON 数据到表 */
    importTable(tableName: string, data: Record<string, unknown>[]): Promise<string[]>;
    /** 导出整个数据库为 JSON */
    exportAll(): Promise<Record<string, Record<string, unknown>[]>>;
    /**
     * v0.5.1: 在线备份 — 导出全库一致性快照。
     * Aria 引擎走引擎级 backup()（MVCC 一致性视图）；其余引擎回退 exportAll()。
     */
    backup(): Promise<Record<string, Record<string, unknown>[]>>;
    private listeners;
    /** 订阅表变更 */
    subscribe(tableName: string, callback: (event: {
        type: string;
        row?: unknown;
        table?: string;
    }) => void): () => void;
    /** 触发变更事件 */
    emit(tableName: string, event: {
        type: string;
        row?: unknown;
        table?: string;
    }): void;
    /** 广播表变更到其他标签页（多标签页同步） */
    broadcastChange(tableName: string): void;
    /** 写语句对应的表名（多标签页广播用） */
    private writeStatementTable;
    /**
     * v0.5.1: SQL 写语句触发 CRUD 生命周期钩子。
     * INSERT/UPDATE/DELETE 分别触发 beforeInsert/afterInsert、beforeUpdate/afterUpdate、
     * beforeDelete/afterDelete（参数与 Table API 路径一致）。
     */
    private triggerStatementHooks;
    private migrations;
    /** 注册迁移 */
    addMigration(version: number, up: (db: MetonaSqlark) => Promise<void>): void;
    /** 执行迁移到指定版本 */
    migrateTo(targetVersion: number): Promise<void>;
    /**
     * 崩溃恢复自愈 — 校验并清理损坏数据、恢复一致性。
     * 检测到异常后调用，无需删库重建。
     */
    repair(): Promise<void>;
    /**
     * 清空全部数据与表结构（保留库本身）。
     * 支持后续继续使用本实例重建表。
     */
    clearAll(): Promise<void>;
    /** 获取插件管理器 */
    getPluginManager(): PluginManager;
    /** 注册钩子 */
    on(hook: HookName, callback: HookCallback): void;
    /** 关闭数据库 */
    close(): Promise<void>;
    /** 获取底层引擎 */
    getEngine(): IStorageEngine;
    private createEngine;
    private ensureReady;
    /** 错误回调分发 */
    private _onError;
    /** 调试日志 */
    private _debug;
}

declare class MemoryEngine implements IStorageEngine {
    readonly name = "memory";
    private tables;
    private schemas;
    private indexes;
    private opened;
    /** v0.4.2-fix: 库内元数据（迁移版本持久化用） */
    private metaStore;
    /**
     * v0.7.4: 由 CREATE UNIQUE INDEX 添加的 unique 列（table:col）。
     * 与建表 UNIQUE 约束区分：DROP INDEX 只允许解除索引来源的 unique，
     * 建表约束需重建表（对齐 SQLite 语义，此前静默解除且不可恢复）。
     */
    private uniqueIndexCols;
    private snapshot;
    open(_dbName: string, _version: number): Promise<void>;
    close(): Promise<void>;
    isOpen(): boolean;
    /** 内存引擎无需修复（无持久化损坏概念） */
    repair(): Promise<void>;
    /** 清空全部数据与表结构 */
    clearAll(): Promise<void>;
    getMeta(key: string): Promise<string | null>;
    setMeta(key: string, value: string): Promise<void>;
    createTable(schema: TableSchema): Promise<void>;
    dropTable(tableName: string): Promise<void>;
    hasTable(tableName: string): Promise<boolean>;
    getTableNames(): Promise<string[]>;
    getTableSchema(tableName: string): Promise<TableSchema | null>;
    /**
     * v0.4.2-fix: 引擎级 ALTER TABLE — 直接修改内存 schema 引用并清理行数据。
     * （此前走 executor 通用路径，行为相同；统一到引擎层保证 Hybrid/IndexedDB 委托一致性）
     */
    alterTable(tableName: string, action: 'ADD' | 'DROP', column: ColumnDef & {
        name: string;
    }): Promise<void>;
    insert(tableName: string, rows: Record<string, unknown>[]): Promise<string[]>;
    /** v0.7.3: 按主键取已验证行（KVStoreEngine 持久化 validated 行用，含 default/类型归一） */
    getRow(tableName: string, pkValue: string): Record<string, unknown> | null;
    find(tableName: string, query: QueryPlan): Promise<Record<string, unknown>[]>;
    /** v0.4.0: 流式查询 — 逐行回调（单次迭代，不物化结果数组） */
    findStream(tableName: string, query: QueryPlan, onRow: (row: Record<string, unknown>) => void): Promise<number>;
    update(tableName: string, query: QueryPlan, updates: Record<string, unknown>): Promise<number>;
    /**
     * v0.7.3: 插入唯一性预检 —— 批内互查（本批前几行写入同一唯一值）
     * + 索引查（表中已有行）。与 update 的 checkUpdateUniqueness 对称，
     * 两阶段 insert 预检阶段调用（索引尚未反映本批写入）。
     */
    private checkInsertUniqueness;
    /**
     * v0.7.3: 更新唯一性预检 — 批内互查（多条行更新到同一唯一值）+ 索引查
     * （排除自身旧条目）。阶段 1 中索引尚未更新，批内互查避免"两行同时改到
     * 同一新值"绕过唯一约束。
     */
    private checkUpdateUniqueness;
    /**
     * v0.7.2: ON UPDATE RESTRICT 预检 — 从 applyUpdateCascade 提取，
     * 两阶段 update 在任何修改前调用（整体拒绝语义）。
     */
    private checkUpdateRestrict;
    /**
     * v0.4.2-fix: ON UPDATE 外键级联 — 被引用表主键变更时处理引用表：
     * RESTRICT 抛错 / CASCADE 更新 FK 值 / SET NULL 置空。
     * v0.7.3-perf: 删除冗余的阶段 1 RESTRICT 扫描 —— checkUpdateRestrict 已在
     * 两阶段 update 预检（阶段 1b）覆盖 RESTRICT 与 SET NULL+required，
     * 此处任何修改前重复全表扫描纯属浪费。直接执行 CASCADE / SET NULL。
     */
    private applyUpdateCascade;
    delete(tableName: string, query: QueryPlan): Promise<number>;
    /**
     * v0.6.3: RESTRICT 预检（delete 级联两阶段之一）。
     * 递归沿 CASCADE 链检查引用表：RESTRICT 引用存在依赖行则抛 FOREIGN_KEY_VIOLATION。
     */
    private checkCascadeRestrict;
    count(tableName: string, query?: QueryPlan): Promise<number>;
    clear(tableName: string): Promise<void>;
    createIndex(tableName: string, column: string, unique?: boolean): Promise<void>;
    dropIndex(tableName: string, column: string, _indexName?: string): Promise<void>;
    beginTransaction(): Promise<void>;
    commitTransaction(): Promise<void>;
    rollbackTransaction(): Promise<void>;
    private deepCloneMapMap;
    private deepCloneIndexes;
    private ensureTable;
    private getPrimaryKey;
    private validateRow;
    private checkType;
    /** 索引查找 */
    private tryIndexLookup;
    /** 更新索引 */
    private updateIndexes;
    /** v0.3.3: 从所有索引中移除一行的条目（update/delete 前调用，修复索引过期/残留） */
    private removeIndexEntries;
    /**
     * 级联删除：查找引用 tableName.pkValue 的所有表的行并删除。
     * v0.6.1-fix: 环路保护（A→B→A 级联环不再无限递归栈溢出，AriaEngine 同语义）。
     * @returns 级联删除的行数
     */
    private cascadeDelete;
}

/**
 * AriaEngine Storage Backend — 存储后端抽象层
 * @module engine/aria/store/backend
 *
 * 封装底层浏览器存储 API（IndexedDB / OPFS / Memory 回退），
 * 供 Buffer Pool 的 PageIO 和 WAL 的 WALStore 使用。
 */
interface IStorageBackend {
    /** 打开存储 */
    open(name: string): Promise<void>;
    /** 关闭存储 */
    close(): Promise<void>;
    /** 是否已打开 */
    isOpen(): boolean;
    /** 读取数据块 */
    read(key: string): Promise<ArrayBuffer | null>;
    /** 写入数据块 */
    write(key: string, data: ArrayBuffer): Promise<void>;
    /**
     * 追加写入（v0.4.5 WAL 分片用，可选）：
     * - OPFS 后端实现真追加（createWritable keepExistingData + seek，O(chunk)）
     * - 未实现的后端由调用方回退 read+write（EncryptedBackend 包装时整体重写保正确性）
     * 语义：在 key 现有内容末尾追加 data；key 不存在时等同 write。
     */
    append?(key: string, data: ArrayBuffer): Promise<void>;
    /**
     * 批量原子写入（v0.4.2-fix）：多个 key 在单个底层事务中提交，
     * 中断时整体回滚，不留半写状态。WAL count 与记录同事务保证一致性。
     */
    writeMany(entries: Record<string, ArrayBuffer>): Promise<void>;
    /** 删除数据块 */
    delete(key: string): Promise<void>;
    /**
     * 批量原子删除（v0.4.2-fix）：多个 key 在单个底层事务中提交。
     */
    deleteMany(keys: string[]): Promise<void>;
    /** 列出所有 key */
    listKeys(): Promise<string[]>;
    /** 检查 key 是否存在 */
    exists(key: string): Promise<boolean>;
    /** 清空所有数据 */
    clear(): Promise<void>;
}

declare class KVStoreEngine implements IStorageEngine {
    readonly name = "kv";
    private kv;
    private memory;
    private dbName;
    private version;
    private opened;
    /** 活跃事务标记 */
    private txActive;
    /** 事务中写过的表（commit 时只 flush 这些表） */
    private txDirtyTables;
    /** 事务中发生 schema 变更（DDL）—— commit 时持久化 schema */
    private txSchemaChanged;
    /**
     * v0.7.0: 事务行级变更记录（table → pk → put/delete）。
     * commit 时按行增量 flush（此前整表 diff：大表事务改 1 行也重写全表）。
     */
    private txChanges;
    /** v0.7.0: 无法行级追踪的表（主键变更/级联影响表）→ commit 时整表 diff */
    private txFullTables;
    /** v0.7.0: 事务内 clear 的表 → commit 时清空 KV 行 */
    private txClearedTables;
    constructor(medium?: IStorageBackend, checkpointThreshold?: number);
    private rowKey;
    private rowPrefix;
    open(dbName: string, version: number): Promise<void>;
    close(): Promise<void>;
    isOpen(): boolean;
    /**
     * v0.6.0: 从 KVStore 重新加载全部数据到内存（多标签页同步重载用）。
     * Hybrid 引擎的 reloadMemoryFromDisk 依赖磁盘引擎"读穿透"，
     * KVStoreEngine 读内存 → 提供 reload 重新加载磁盘最新数据。
     */
    reload(): Promise<void>;
    /** v0.4.2-fix: 自愈 — 校验 KVStore 日志/快照完整性并重建内存 */
    repair(): Promise<void>;
    clearAll(): Promise<void>;
    getMeta(key: string): Promise<string | null>;
    setMeta(key: string, value: string): Promise<void>;
    createTable(schema: TableSchema): Promise<void>;
    dropTable(tableName: string): Promise<void>;
    hasTable(tableName: string): Promise<boolean>;
    getTableNames(): Promise<string[]>;
    getTableSchema(tableName: string): Promise<TableSchema | null>;
    alterTable(tableName: string, action: 'ADD' | 'DROP', column: ColumnDef & {
        name: string;
    }): Promise<void>;
    insert(tableName: string, rows: Record<string, unknown>[]): Promise<string[]>;
    find(tableName: string, query: QueryPlan): Promise<Record<string, unknown>[]>;
    findStream(tableName: string, query: QueryPlan, onRow: (row: Record<string, unknown>) => void): Promise<number>;
    update(tableName: string, query: QueryPlan, updates: Record<string, unknown>): Promise<number>;
    delete(tableName: string, query: QueryPlan): Promise<number>;
    count(tableName: string, query?: QueryPlan): Promise<number>;
    clear(tableName: string): Promise<void>;
    createIndex(tableName: string, column: string, unique?: boolean): Promise<void>;
    dropIndex(tableName: string, column: string, indexName?: string): Promise<void>;
    beginTransaction(): Promise<void>;
    commitTransaction(): Promise<void>;
    rollbackTransaction(): Promise<void>;
    private ensureOpen;
    private getPK;
    /** 收集匹配查询的内存行主键（持久化差异计算用） */
    private collectMatchingPks;
    /**
     * 计算外键级联影响的表集合（传递闭包：A 被 B 引用，B 被 C 引用 → {A, B, C}）。
     * 级联操作（delete/update 主键）需要把这些表一并重写持久化。
     */
    private affectedTables;
    /** 持久化 schema（全部表） */
    private persistSchema;
    /**
     * v0.6.1: 整表 diff 收集（不落盘）：内存行全部 put + KV 残留行删除。
     * 调用方合并到单次原子 writeBatch（put+delete 同一条日志记录，多表操作真原子）。
     */
    private collectTableDiff;
}

declare class AriaEngine implements IStorageEngine {
    readonly name = "aria";
    private config;
    private lsm;
    private wal;
    private checkpointManager;
    private backend;
    private opened;
    private dbName;
    private fileManager;
    private bufferPool;
    private dbLock;
    private schemas;
    private tablePKs;
    private opCounter;
    private secondaryIndexes;
    /**
     * v0.7.4: 由 CREATE UNIQUE INDEX 添加的 unique 列（table:col）。
     * 与建表 UNIQUE 约束区分：DROP INDEX 只允许解除索引来源的 unique，
     * 建表约束需重建表（对齐 SQLite 语义，此前静默解除且重启后永久消失）。
     * 注：重启后无法区分历史来源，schema 中的 unique 一律按建表约束保护（保守）。
     */
    private uniqueIndexCols;
    private mvcc;
    private currentTxnId;
    private txnSnapshot;
    private gcCounter;
    constructor(config?: AriaEngineConfig);
    open(dbName: string, _version: number): Promise<void>;
    /** open 内部实现（错误包装在 open 外层） */
    private openInternal;
    close(): Promise<void>;
    /**
     * v0.4.2-fix: 崩溃恢复/自愈 — 校验并移除损坏 SSTable、截断 WAL、重建二级索引。
     * v0.4.5 增强：清理 OPFS 残留临时文件、清理孤儿页面（meta 未引用的 pg_ 文件）。
     * 应用层检测到异常后调用，无需删库重建。
     */
    repair(): Promise<void>;
    /**
     * v0.4.5: 清理孤儿页面 — 扫描全部 pg_* 文件，未被任何 LSM 命名空间 meta 引用的删除。
     * 孤儿页面来自：崩溃中断的 compaction/删除流程（旧 SSTable 页面残留）。
     */
    private cleanupOrphanPages;
    /**
     * v0.4.1: 重置数据库 — 清空全部数据与表结构（演示页刷新/重新初始化用）。
     * 清空存储后端、LSM、WAL、MVCC 与二级索引，后续可继续使用本实例。
     */
    clearAll(): Promise<void>;
    isOpen(): boolean;
    getMeta(key: string): Promise<string | null>;
    setMeta(key: string, value: string): Promise<void>;
    createTable(schema: TableSchema): Promise<void>;
    dropTable(tableName: string): Promise<void>;
    /**
     * v0.4.2-fix: 清理指定表的全部二级索引 LSM（内存 + 存储文件 + meta）。
     * dropTable / DROP_TABLE 恢复 / alterTable DROP 索引列 共用。
     */
    private cleanupTableIndexes;
    hasTable(tableName: string): Promise<boolean>;
    getTableNames(): Promise<string[]>;
    getTableSchema(tableName: string): Promise<TableSchema | null>;
    insert(tableName: string, rows: Record<string, unknown>[]): Promise<string[]>;
    find(tableName: string, query: QueryPlan): Promise<Record<string, unknown>[]>;
    update(tableName: string, query: QueryPlan, updates: Record<string, unknown>): Promise<number>;
    /**
     * v0.7.2: 批内唯一互查 — 两条行在同一语句中更新到同一唯一值时的兜底检查
     * （阶段 1 中索引尚未反映本语句的变更）。
     */
    private checkBatchUnique;
    /**
     * v0.7.2: ON UPDATE 外键预检 — 从 applyForeignKeyUpdateRules 提取（两阶段 update 用）：
     * RESTRICT 存在依赖行抛错；SET NULL 撞 required 列同样整体拒绝。
     */
    private checkForeignKeyUpdateRestrict;
    /**
     * v0.4.2-fix: ON UPDATE 外键级联 — 主键 oldPk → newPk 时处理引用表。
     * RESTRICT 抛错 / CASCADE 更新 FK / SET NULL 置空（含索引与 WAL 记录）。
     * 两阶段：先全量 RESTRICT 检查，再执行级联。
     */
    private applyForeignKeyUpdateRules;
    delete(tableName: string, query: QueryPlan): Promise<number>;
    /**
     * v0.6.3: RESTRICT 预检（delete 级联两阶段之一，与 MemoryEngine 对齐）。
     * 递归沿 CASCADE 链检查引用表：RESTRICT 引用存在依赖行则抛 FOREIGN_KEY_VIOLATION。
     */
    private checkCascadeRestrict;
    /**
     * v0.4.1: 外键级联规则 — 对齐 MemoryEngine.cascadeDelete 行为。
     * 删除 tableName 主键为 pkValue 的行前，检查引用它的所有表：
     * - RESTRICT: 存在引用行 → 抛 FOREIGN_KEY_VIOLATION
     * - CASCADE: 递归删除引用行（含索引/WAL）
     * - SET NULL: 引用行外键列置 null（含索引/WAL）
     * @returns 级联影响的行数（CASCADE 删除行数 + SET NULL 更新行数）
     */
    private applyForeignKeyRules;
    /**
     * v0.4.0: 流式查询 — 逐行回调，不物化结果数组。
     * 全表路径走 LSM rangeScanLazy 惰性扫描；索引等值/范围路径复用 tryIndexLookup。
     * 事务中回退物化（快照合并需要全量行集）。
     */
    findStream(tableName: string, query: QueryPlan, onRow: (row: Record<string, unknown>) => void): Promise<number>;
    count(tableName: string, query?: QueryPlan): Promise<number>;
    clear(tableName: string): Promise<void>;
    /**
     * v0.4.1: ALTER TABLE — 结构变更真正生效于存储：
     * - ADD: 持久化 schema（persistSchemas），行无需修改
     * - DROP: 持久化 schema + 遍历主 LSM 重写所有行（移除该列键）+ WAL UPDATE 记录
     * （通用路径 getTableSchema 返回副本，Executor 的引用修改对 Aria 无效）
     */
    alterTable(tableName: string, action: 'ADD' | 'DROP', column: ColumnDef & {
        name: string;
    }): Promise<void>;
    createIndex(tableName: string, column: string, unique?: boolean): Promise<void>;
    dropIndex(tableName: string, column: string, _indexName?: string): Promise<void>;
    beginTransaction(): Promise<void>;
    commitTransaction(): Promise<void>;
    rollbackTransaction(): Promise<void>;
    private savepoints;
    savepoint(name: string): Promise<void>;
    rollbackToSavepoint(name: string): Promise<void>;
    releaseSavepoint(name: string): Promise<void>;
    backup(): Promise<Record<string, Record<string, unknown>[]>>;
    private getAllRows;
    /**
     * v0.3.3: 将事务未提交快照的变更合并到行列表（新增/更新/删除标记）。
     * 幂等操作：行已是最新时不重复修改。
     */
    private mergeTxnSnapshot;
    private getPK;
    private validateRow;
    private checkType;
    private persistSchemas;
    private loadSchemas;
    /**
     * 创建命名空间隔离的 SSTableStore。
     *
     * 主 LSM 与每个二级索引 LSM 各持有独立实例：
     * - 文件 key 前缀隔离（sst_ / sst_idx_${table}_${col}_）
     * - 元数据 key 隔离（__aria_lsm_meta / __aria_lsm_meta_${ns}）
     * - id 序列独立（避免 v0.2.4 共享 id 空间导致的文件互相覆盖）
     */
    private createSSTableStore;
    /** v0.4.5: 是否启用页面化物理存储（默认 OPFS / KVStore 后端启用，显式配置可覆盖） */
    private isPageStorage;
    private applyWALRecord;
    /**
     * v0.3.3: DROP_TABLE 恢复 — 删除 schema 并清除主 LSM 中该表的所有残留数据。
     *
     * 此前 DROP_TABLE 在恢复时被忽略，而 CREATE_TABLE 回放会重建 schema，
     * 导致崩溃后"已删除的表和数据复活"（实证 P0 bug）。
     */
    private applyDropTableRecovery;
    /** v0.6.2: 表中有 unique 约束且索引 LSM 已建的列（唯一性检查范围） */
    private uniqueColumns;
    /**
     * v0.6.2: 同步唯一性检查（须在批次级 prefetchPrefixRanges 之后调用，循环内无 await）。
     * 索引不含 null 条目（null 值不受唯一约束，与 MemoryEngine 语义一致）。
     * @param currentPk 当前行主键（更新路径用于排除自身旧索引条目；插入路径无自身条目）
     */
    private checkUniqueSync;
    /** 更新行的二级索引条目 */
    private updateSecondaryIndexes;
    /** 通过二级索引快速查找 */
    private tryIndexLookup;
    /** 从索引扫描结果恢复完整行 */
    private indexScanToRows;
    /** 每 10 次 gc 计数器触发一次 MVCC 垃圾回收 */
    private tryGC;
    /** 回收主 LSM 与所有二级索引 LSM 的临时缓存超限 */
    private trimAllCaches;
    /** 检查内存预算，超出时强制 flush + GC */
    private checkMemoryBudget;
    /**
     * ANALYZE: 收集表统计信息
     * 返回行数、平均行大小、索引深度等
     */
    analyzeTable(tableName: string): Promise<Record<string, unknown>>;
    /**
     * REINDEX: 重建指定表的所有二级索引
     */
    reindexTable(tableName: string): Promise<number>;
    /** v0.4.2-fix: 重建索引内部实现（不校验 opened，供 open 恢复流程调用） */
    private reindexTableInternal;
    /**
     * VACUUM: 压缩 LSM + 清理碎片
     */
    vacuum(): Promise<{
        compactedLevels: number;
        gcVersions: number;
    }>;
    private ensureOpen;
    /** v0.4.2-fix: Aria 事务中 DDL 显式拒绝（结构变更无法通过行快照回滚） */
    private ensureNoDDLInTransaction;
    private ensureTable;
}

declare class HybridEngine implements IStorageEngine {
    readonly name = "hybrid";
    private memoryEngine;
    private diskEngine;
    private diskEngineType;
    private dbName;
    private version;
    constructor(diskEngine?: DiskEngine);
    open(dbName: string, version: number): Promise<void>;
    /**
     * 从磁盘重载内存缓存（v0.3.2：多标签页同步）。
     * 其他标签页写入磁盘后调用，使本标签页读到最新数据。
     */
    reloadMemoryFromDisk(): Promise<void>;
    close(): Promise<void>;
    isOpen(): boolean;
    /** 自愈：修复磁盘引擎后重载内存缓存 */
    repair(): Promise<void>;
    /** 清空全部数据与表结构 */
    clearAll(): Promise<void>;
    getMeta(key: string): Promise<string | null>;
    setMeta(key: string, value: string): Promise<void>;
    createTable(schema: TableSchema): Promise<void>;
    dropTable(tableName: string): Promise<void>;
    hasTable(tableName: string): Promise<boolean>;
    getTableNames(): Promise<string[]>;
    getTableSchema(tableName: string): Promise<TableSchema | null>;
    /** v0.4.2-fix: 引擎级 ALTER TABLE — 双引擎同步（磁盘持久化 + 内存引用） */
    alterTable(tableName: string, action: 'ADD' | 'DROP', column: ColumnDef & {
        name: string;
    }): Promise<void>;
    /**
     * v0.7.2: 磁盘写失败补偿 — 内存已先行写入、磁盘失败 → 内存与磁盘不一致
     * （重启后数据丢失且调用方已收到错误）。从磁盘重载内存对齐真实状态
     * （内存=磁盘），再重新抛出原始错误。事务路径由双引擎快照回滚保证，
     * 无需此补偿。
     */
    private recoverMemoryAfterDiskError;
    insert(tableName: string, rows: Record<string, unknown>[]): Promise<string[]>;
    find(tableName: string, query: QueryPlan): Promise<Record<string, unknown>[]>;
    /** v0.4.0: 流式查询（内存引擎逐行回调） */
    findStream(tableName: string, query: QueryPlan, onRow: (row: Record<string, unknown>) => void): Promise<number>;
    update(tableName: string, query: QueryPlan, updates: Record<string, unknown>): Promise<number>;
    delete(tableName: string, query: QueryPlan): Promise<number>;
    count(tableName: string, query?: QueryPlan): Promise<number>;
    clear(tableName: string): Promise<void>;
    createIndex(tableName: string, column: string, unique?: boolean): Promise<void>;
    dropIndex(tableName: string, column: string, indexName?: string): Promise<void>;
    beginTransaction(): Promise<void>;
    commitTransaction(): Promise<void>;
    rollbackTransaction(): Promise<void>;
    /** 获取磁盘引擎类型 */
    getDiskEngineType(): DiskEngine;
    /** 获取内存引擎（供内部使用） */
    getMemoryEngine(): MemoryEngine;
}

/**
 * metona-sqlark SQL Parser — 递归下降语法分析器
 * @module sql/parser
 *
 * Token 流 → AST Statement。
 * 支持的语法是标准 SQL 的子集。
 */

/** 解析 SQL 字符串为 AST Statement */
declare function parse(sql: string): Statement;
/** 解析 SQL 字符串为 AST Statement 数组（分号分隔的多语句支持，v0.3.0） */
declare function parseAll(sql: string): Statement[];

/**
 * metona-sqlark SQL Token Types — 词法单元定义
 * @module sql/tokens
 */
declare enum TokenType {
    SELECT = "SELECT",
    FROM = "FROM",
    WHERE = "WHERE",
    INSERT = "INSERT",
    INTO = "INTO",
    VALUES = "VALUES",
    UPDATE = "UPDATE",
    SET = "SET",
    DELETE = "DELETE",
    CREATE = "CREATE",
    TABLE = "TABLE",
    DROP = "DROP",
    ORDER = "ORDER",
    BY = "BY",
    ASC = "ASC",
    DESC = "DESC",
    LIMIT = "LIMIT",
    OFFSET = "OFFSET",
    AND = "AND",
    OR = "OR",
    NOT = "NOT",
    LIKE = "LIKE",
    IN = "IN",
    PRIMARY = "PRIMARY",
    KEY = "KEY",
    UNIQUE = "UNIQUE",
    DEFAULT = "DEFAULT",
    NULL = "NULL",
    TRUE = "TRUE",
    REFERENCES = "REFERENCES",
    CASCADE = "CASCADE",
    BETWEEN = "BETWEEN",
    IF = "IF",
    EXISTS = "EXISTS",
    FALSE = "FALSE",
    ALTER = "ALTER",
    ADD = "ADD",
    TRUNCATE = "TRUNCATE",
    INNER = "INNER",
    LEFT = "LEFT",
    RIGHT = "RIGHT",
    CROSS = "CROSS",
    JOIN = "JOIN",
    ON = "ON",
    AS = "AS",
    OUTER = "OUTER",
    GROUP = "GROUP",
    HAVING = "HAVING",
    COUNT = "COUNT",
    SUM = "SUM",
    AVG = "AVG",
    MIN = "MIN",
    MAX = "MAX",
    DISTINCT = "DISTINCT",
    BEGIN = "BEGIN",
    COMMIT = "COMMIT",
    ROLLBACK = "ROLLBACK",
    UNION = "UNION",
    ALL = "ALL",
    INDEX = "INDEX",
    CASE = "CASE",
    WHEN = "WHEN",
    THEN = "THEN",
    ELSE = "ELSE",
    END = "END",
    EXPLAIN = "EXPLAIN",
    ANALYZE = "ANALYZE",
    REINDEX = "REINDEX",
    VACUUM = "VACUUM",
    SAVEPOINT = "SAVEPOINT",
    RELEASE = "RELEASE",
    TO = "TO",
    IDENTIFIER = "IDENTIFIER",
    STRING = "STRING",
    NUMBER = "NUMBER",
    COMMA = "COMMA",
    LPAREN = "LPAREN",
    RPAREN = "RPAREN",
    SEMICOLON = "SEMICOLON",
    EQ = "EQ",
    NEQ = "NEQ",
    GT = "GT",
    GTE = "GTE",
    LT = "LT",
    LTE = "LTE",
    STAR = "STAR",
    DOT = "DOT",
    EOF = "EOF",
    ILLEGAL = "ILLEGAL"
}
interface Token {
    type: TokenType;
    value: string;
    position: number;
}

/**
 * metona-sqlark SQL Lexer — 词法分析器
 * @module sql/lexer
 *
 * 将 SQL 字符串切分为 Token 流。
 */

/** 将 SQL 字符串解析为 Token 列表 */
declare function tokenize(sql: string): Token[];

/**
 * AriaEngine OPFS Backend — 基于 Origin Private File System 的自研存储后端
 * @module engine/aria/store/opfs_backend
 *
 * 零外部依赖，纯浏览器文件系统 API。
 * 每个 key 对应 OPFS 目录下的一个二进制文件。
 *
 * 原子性与一致性保证（v0.4.5 固化）：
 * - 单文件 write/append：createWritable 为 copy-on-write —— close 前崩溃旧文件保持不变，
 *   close 后原子替换（单文件写入原子）
 * - 多文件 writeMany/deleteMany：OPFS 无跨文件事务，串行逐个落盘；调用方（WAL 分片）
 *   已改为单文件语义，多键操作仅用于一次性的 schema/meta 写入
 * - 所有写操作串行队列化（同源同进程顺序一致）；单次任务失败不中断队列链，
 *   错误如实返回给该次调用的调用方
 * - close() 等待写队列排空后再释放目录句柄（杜绝 close 后挂起写丢失/读旧数据）
 * - open() 自动清理崩溃残留临时文件（Chromium createWritable 的 .crswap 等）
 *
 * 浏览器要求：Chrome 102+ / Edge 102+（Safari 15.2+ / Firefox 111+ 支持基础 OPFS）
 */

declare class OPFSBackend implements IStorageBackend {
    private root;
    private dbDir;
    private dbName;
    private writeQueue;
    open(name: string): Promise<void>;
    close(): Promise<void>;
    isOpen(): boolean;
    /** 清理崩溃残留的临时文件（open 时自动调用，repair 也可调用） */
    cleanupStaleFiles(): Promise<void>;
    read(key: string): Promise<ArrayBuffer | null>;
    /**
     * 单文件原子写：createWritable 为 copy-on-write，close 后原子替换；
     * 写入期间崩溃 → 旧文件保持（原子性由浏览器 OPFS 实现保证）。
     */
    write(key: string, data: ArrayBuffer): Promise<void>;
    /**
     * v0.4.5: 真追加写 — createWritable(keepExistingData) + seek 到文件末尾。
     * 单文件 COW 原子（close 前崩溃旧文件保持），无需读旧内容即实现 O(chunk) 追加
     * （WAL 分片高频写入用）。
     */
    append(key: string, data: ArrayBuffer): Promise<void>;
    /** v0.4.2-fix: 批量写入 — 串行队列内逐个落盘（OPFS 无跨文件事务，顺序保证一致） */
    writeMany(entries: Record<string, ArrayBuffer>): Promise<void>;
    delete(key: string): Promise<void>;
    /** v0.4.2-fix: 批量删除 — 串行队列内逐个删除 */
    deleteMany(keys: string[]): Promise<void>;
    listKeys(): Promise<string[]>;
    exists(key: string): Promise<boolean>;
    clear(): Promise<void>;
}

/**
 * metona-sqlark — 入口文件
 * @module metona-sqlark
 * @version 0.4.1
 *
 * 前端关系型数据库，内存与磁盘双模式。
 * 支持 Query Builder 链式 API 和 SQL 字符串查询。
 */

/**
 * 创建数据库实例并初始化
 *
 * @example
 * ```ts
 * const db = await MetonaSqlark.create({
 *   name: 'my-app',
 *   mode: 'hybrid',
 * });
 *
 * await db.defineTable('users', {
 *   id: { type: 'string', primaryKey: true },
 *   name: { type: 'string', required: true },
 * });
 *
 * await db.table('users').insert({ id: '1', name: 'Alice' });
 * const results = await db.query('SELECT * FROM users');
 * ```
 */
declare function create(config: DatabaseConfig): Promise<MetonaSqlark>;
declare const api: {
    VERSION: string;
    version: string;
    create: typeof create;
    MetonaSqlark: typeof MetonaSqlark;
    MeSqlark: typeof MetonaSqlark;
};
declare global {
    interface Window {
        MetonaSqlark: typeof api;
        MeSqlark: typeof api;
    }
}

declare const MeSqlark: typeof MetonaSqlark;

export { AriaEngine, AriaEngineConfig, ColumnDef, DatabaseConfig, DeleteStatement, DiskEngine, FieldType, HybridEngine, IStorageEngine, InsertStatement, KVStoreEngine, MeSqlark, MemoryEngine, MetonaSqlark, OPFSBackend, SelectStatement, Statement, StorageMode, Table, TableSchema, UpdateStatement, VERSION, api, create, api as default, parse, parseAll, tokenize };