gs-idb-pro/lib/index.d.ts

> A full-featured wrapper for browser IndexedDB

import { StrOrNum, IDisposable } from 'gs-base';
import { DbQuery } from 'gs-idb-basic';

interface IDbLtRange {
    /**
     * 小于该值
     */
    lt: IDBValidKey;
}
interface IDbGtRange {
    /**
     * 大于该值
     */
    gt: IDBValidKey;
}
interface IDbLteRange {
    /**
     * 小于或等于该值
     */
    lte: IDBValidKey;
}
interface IDbGteRange {
    /**
     * 大于或等于该值
     */
    gte: IDBValidKey;
}
interface IDbLtGtRange extends IDbLtRange, IDbGtRange {
}
interface IDbLtGteRange extends IDbLtRange, IDbGteRange {
}
interface IDbLteGtRange extends IDbLteRange, IDbGtRange {
}
interface IDbLteGteRange extends IDbLteRange, IDbGteRange {
}
type IDbRange = IDbLtRange | IDbGtRange | IDbLteRange | IDbGteRange | IDbLtGtRange | IDbLtGteRange | IDbLteGtRange | IDbLteGteRange;
type IDbQuery = IDBValidKey | IDbRange;

interface ICursorOption {
    query?: IDbQuery;
    /**
     * 游标滚动方向，默认为`prev`
     */
    direction?: IDBCursorDirection;
    /**
     * 预先跳过条数
     */
    preSkip?: number;
    /**
     * 从指定的`key`开始, 如果存在`preSkip`会先跳过`preSkip`
     * - 当前`store`必须存在其`key`的索引
     */
    startKey?: IDBValidKey;
    /**
     * 从指定的'Key'与`PrimaryKey`开始
     * - 使用`startPrimaryKey`时必须同时存在`startKey`
     * - 当前`store`必须存在其`key`的索引
     */
    startPrimaryKey?: IDBValidKey;
}
interface ICursorRow {
    cursor: IDBCursorWithValue;
    end: () => void;
}

interface IIndexSchema {
    name: string;
    keyPath?: string | string[];
    unique?: boolean;
    multiEntry?: boolean;
}
type IndexSchema = string | IIndexSchema;

/**
 * 特殊字段定义
 */
interface ISpecialFieldSchema {
    /**
     * 为 false 时代表不支持该字段
     * 为 true 时代表使用默认值
     */
    name: boolean | string;
    /**
     * 是否在`store`未定义同名索引时，自动创建索引
     * 默认值为`true`
     */
    isIndexed?: boolean;
}
/**
 * 为 false 或 name 为 false 时代表不支持该字段
 * 未定义,或为 true 时代表使用默认值
 */
type SpecialFieldSchema = boolean | string | ISpecialFieldSchema;

interface ISpecialFields {
    /**
     * 添加时间
     * 默认值为 `added_at`
     *  值为`false` 时代表不创建该字段
     */
    addedTimeField?: SpecialFieldSchema;
    /**
     * 最后修改数据时间
     * 默认值为 `updated_at`
     *  值为`false` 时代表不创建该字段
     */
    updatedTimeField?: SpecialFieldSchema;
    /**
     * 累计修改次数
     * 默认值为 `false`
     * 默认字段名为 `updated_count`
     */
    updatedCountField?: SpecialFieldSchema;
    /**
     * 软删除字段
     * 默认值为 `false`
     * 默认字段名为 `deleted`
     */
    softDeletedField?: SpecialFieldSchema;
}
interface IStoreSchemaTemplate extends ISpecialFields {
    /**
     * 主键包含在数据中的路径
     * 未定义时，数据中将不包含主键
     */
    keyPath?: string | string[];
    autoIncrement?: boolean;
    /**
     * 索引定义,为字符串时表示索引名称与keyPath
     */
    indexSchemas?: IndexSchema[];
}
declare const defaultStoreSchemaTemplate: Readonly<IStoreSchemaTemplate>;
/**
 * @template R 在有`mapper`时返回值的类型
 * @template V 原始`store`一行数据的类型
 */
type GetRowMapper<R, V> = (item: V, key: IDBValidKey, i: number) => R | Promise<R>;
/**
 * @template R 在有`mapper`时返回值的类型
 * @template V 原始`store`一行数据的类型
 */
type SaveRowMapper<R, V> = (item: DbRecord<V>) => DbRecord<V> | Promise<DbRecord<V>>;
interface IStoreSchema extends IStoreSchemaTemplate {
    name: string;
    /**
     * 在完成数据库Store定义后执行
     * 用于添加默认数据
     * 或 用于升级了store结构后对旧数据进行升级
     */
    storeDefined?: (store: IStoreUpgradeable) => void | Promise<void>;
    /**
     * 用于在`store`创建时添加默认数据
     * -如果当前`store` 存在 `keyPath` 可以使用任意合法数据
     * -如果不存在 `keyPath` 则必须包含 `key` 与 `value` 字段
     */
    defaultData?: DbRecord[];
    /**
     * 用于在数据库升级时，在指定版本范围更新的数据
     */
    versionData?: IVersionData[];
    /**
     * 在调用所有支持`mapper`方法获取数据时的默认映射
     */
    defaultGetMapper?: GetRowMapper<any, any>;
    /**
     * 用于在`store`导出数据时的映射
     * - `string[]` 代表要导出的字段
     * - 如果不存在`keyPath`,不支持`string[]`
     */
    exportMapper?: GetRowMapper<any, any> | string[];
    /**
     * 在调所有保存数据方法时的默认映射
     */
    defaultSaveMapper?: SaveRowMapper<any, any>;
    /**
     * 用于在调用`store.add()`添加数据时的映射
     */
    addMapper?: SaveRowMapper<any, any>;
    /**
     * 用于在调用`store.replace()`替换数据时的映射
     */
    replaceMapper?: SaveRowMapper<any, any>;
    /**
     * 用于在调用`store.change()`修改数据时的映射
     */
    changeMapper?: SaveRowMapper<any, any>;
}
type StoreSchema = string | IStoreSchema;

/**
 * 中断循环，并且忽略返回的`value`值
 */
declare const Break: unique symbol;
/**
 * 完成循环：结束循环并将当前`value`包含在返回值中
 */
declare const Finished: unique symbol;
/**
 * 忽略`value`值，该`value`值将不会包含在返回值中
 */
declare const Continue: unique symbol;
/**
 * 跳转到指定的Key，并且忽略返回的`value`值
 */
declare const ContinueKey: unique symbol;
/**
 * 跳转到指定的`Key`
 */
declare const NextKey: unique symbol;
/**
 * 跳转到指定的`PrimaryKey`，并且忽略返回的value`值
 */
declare const ContinuePrimaryKey: unique symbol;
/**
 * 跳转到指定的`PrimaryKey`
 */
declare const NextPrimaryKey: unique symbol;
type VoidControl = typeof Break | typeof ContinueKey | typeof ContinuePrimaryKey | null;
interface IVoidResult {
    control?: VoidControl;
    key?: IDBValidKey;
    primaryKey?: IDBValidKey;
}
type VoidResult = typeof Break | IVoidResult | null | undefined | void;
type ValueControl = VoidControl | typeof Finished | typeof Continue | typeof NextKey | typeof NextPrimaryKey;
interface IValueResult<V = any> {
    /**
     * 控制循环流程
     */
    control?: ValueControl;
    value?: V;
    key?: IDBValidKey;
    primaryKey?: IDBValidKey;
}
type VoidCallFn<Row = any> = (value: Row, key: IDBValidKey, i: number) => VoidResult | Promise<VoidResult>;
type ValueCallFn<Row = any, Rtn = any> = (value: Row, key: IDBValidKey, i: number, results: DbRecordResult<Rtn>[]) => void | IValueResult<Rtn> | Promise<void | IValueResult<Rtn>>;
interface IForEachArg<Row = any> extends ICursorOption {
    fn: VoidCallFn<Row>;
}
interface IForEachResultArg<Row = any, Rtn = any> extends ICursorOption {
    fn?: ValueCallFn<Row, Rtn>;
    /**
     * 值为数组时，代表要返回的字段
     */
    mapper?: GetRowMapper<Rtn, Row> | string[] | undefined;
}
interface IForEachable<Row = any> {
    forEach<Val extends Row = Row>(fn: VoidCallFn<Val> | IForEachArg<Val>): Promise<void>;
    forEach<Rtn = DbRecordResult<Row>, Val extends Row = Row>(fn: ValueCallFn<Val, Rtn> | IForEachResultArg<Val, Rtn>, returns: true): Promise<Rtn[]>;
}

interface IInfoTarget {
    store: string;
    index?: string;
}
type NativeTarget = IDBObjectStore | IDBIndex;
type OperationTarget = NativeTarget | IInfoTarget;
declare function isNativeTarget(target: any): target is IDBObjectStore | IDBIndex;

type IDbIteratorParser<T = any> = (cusor: IDBCursorWithValue) => IValueResult<T> | Promise<IValueResult<T>>;
declare const DbIteratorParsers: Readonly<{
    key: ({ primaryKey: value }: IDBCursorWithValue) => {
        value: IDBValidKey;
    };
    value: ({ value }: IDBCursorWithValue) => {
        value: any;
    };
    keyValue: ({ primaryKey: key, value }: IDBCursorWithValue) => {
        value: any[];
    };
}>;
type DbIteratorParsersKey = keyof typeof DbIteratorParsers;
interface IDbIteratorArg extends ICursorOption {
    endsWithNull?: boolean;
}
interface IDbIteratorOption<T> extends Readonly<IDbIteratorArg> {
    readonly writable?: boolean;
    readonly parser?: DbIteratorParsersKey | IDbIteratorParser<T>;
}
interface IDbIterator<Row = any, Tar extends OperationTarget = OperationTarget> extends IDbIteratorOption<Row>, AsyncIterable<Row> {
}

interface ICursorReader<T> {
    iterator(arg?: IDbQuery | IDbIteratorArg): AsyncIterable<T>;
    iterator(query: IDbQuery, direction?: IDBCursorDirection): AsyncIterable<T>;
}

/**
 * @template R 在有`mapper`时返回值的类型
 * @template V 原始`store`一行数据的类型
 */
interface IPageArg<R = any, V = any> extends Omit<IFindMapArg<R, V>, 'preSkip' | 'startKey' | 'startPrimaryKey'> {
    /**
     * 获取第几页
     */
    page?: number;
    /**
     * 分页大小限制
     * - 默认为100
     */
    size?: number;
}
interface IPageInfo<R = any, V = any> extends Readonly<Required<IPageArg<R, V>>> {
    readonly total: number;
    readonly pages: number;
    /**
     * 下一页需要跳过的行
     */
    readonly nextSkip: number;
}
/**
 * @template R 在有`mapper`时返回值的类型
 * @template V 原始`store`一行数据的类型
 */
interface IPage<R = any, V = any> {
    info: IPageInfo<R, V>;
    rows: R[];
}
interface IPageableQuery<T> {
    page<R = ArrayDbRecord<T>>(): Promise<IPage<R, T>>;
    /**
     * 获取一页数据
     * - 仅当在获取第一页与指定页时调用此方法
     * - 如果是获取下一页则应该调用`nextPage(info:IPageInfo)`方法
     * @param arg 获取后续页时，请使用上一次的`info`
     * @param page  获取第几页，如果存在，将覆盖`arg.page`
     */
    page<R = ArrayDbRecord<T>>(arg: IPageArg<R, T> | IPageInfo<R, T>, page?: number): Promise<IPage<R, T>>;
    /**
     * 获取下一页
     * @param info 上一页的`info`字段
     */
    nextPage<R = ArrayDbRecord<T>>(info: IPageInfo<R, T>): Promise<IPage<R, T>>;
}

interface IValidDataOperationSchema<T extends OperationTarget> {
    storeSchema?: IStoreSchema;
    target: T;
}

interface IDbMap<K extends StrOrNum = StrOrNum, V = any, Tar extends OperationTarget = OperationTarget> extends IValidDataOperationSchema<Tar>, IForEachable<V> {
    readonly size: Promise<number>;
    has(key: K): Promise<boolean>;
    get<T extends V = V>(key: K, defaultValue?: T): Promise<T | undefined>;
    getMany<T extends V = V>(keys: K[]): Promise<(T | undefined)[]>;
    set<T extends V = V>(key: K, value: T): Promise<void>;
    setMany<T extends V = V>(values: [K, V][]): Promise<void>;
    delete(key: K): Promise<void>;
    keys(): AsyncIterable<K>;
    values<T extends V = V>(): AsyncIterable<T>;
    entries<T extends V = V>(): AsyncIterable<[K, T]>;
    /**
     * 转换工作目标
     * - 如果当前`target`为`store`，则返回`this`
     * - 如果当前`target`为`index`，则创建基于其`store`的新实例
     */
    asStore(): IDataReader<V, Tar>;
    /**
     * 转换工作目标
     * - 如果当前`target`为`store`，则返回`this`
     * - 如果当前`target`为`index`，则创建其`store`的副本
     */
    asStore(writable: true): IDataWriter<V, Tar>;
    batch<R = any, T extends V = V>(fn: (map: IDbMap<K, T, NativeTarget>) => R | Promise<R>): Promise<R>;
}

interface IGetAllArgs<T> {
    query?: IDbQuery | null;
    /**
     * 最多返回条数,默认值为1000
     */
    limit?: number;
}
interface IDataReader<Row = any, Tar extends OperationTarget = OperationTarget> extends IValidDataOperationSchema<Tar>, ICursorReader<Row>, IForEachable<Row>, ICursorQueryable<Row>, IPageableQuery<Row> {
    readonly storeName: string;
    readonly storeSchema: IStoreSchema;
    /**
     * @param query
     * @param limit 最多返回条数,默认值为1000
     */
    all(query?: IDbQuery, limit?: number): Promise<Row[]>;
    all(args?: IGetAllArgs<Row>): Promise<Row[]>;
    /**
     * 返回满足条件的第一条数据
     * @param key
     */
    get(key: IDbQuery): Promise<Row | undefined>;
    /**
     * 获取满足每一个条件的第一条数据
     * @param keys
     * @param excludeEmpty 是否排除空数据
     */
    getMany(keys: IDbQuery[], excludeEmpty?: boolean): Promise<Row[]>;
    /**
     * 创建基于`name`索引的新实例
     */
    index(name: string): IDataReader<Row, Tar>;
    /**
     * 创建基于`name`索引的新实例
     */
    index(name: string, writable: true): IDataWriter<Row, Tar>;
    /**
     * 转换工作目标
     * - 如果当前`target`为`store`，则返回`this`
     * - 如果当前`target`为`index`，则创建基于其`store`的新实例
     */
    asStore(): IDataReader<Row, Tar>;
    /**
     * 转换工作目标
     * - 如果当前`target`为`store`，则返回`this`
     * - 如果当前`target`为`index`，则创建其`store`的副本
     */
    asStore(writable: true): IDataWriter<Row, Tar>;
    /**
     * 创建基于当前`target`的`IDbMap`实例
     */
    asMap<Key extends StrOrNum = StrOrNum>(): IDbMap<Key, Row, Tar>;
    batchRead<R = any>(fn: (reader: IDataReader<Row, NativeTarget>) => Promise<R | void>): Promise<R>;
}
type NativeReader<T = any> = IDataReader<T, NativeTarget>;

declare const Save: unique symbol;
declare const Delete: unique symbol;
interface IModifyResult<Row, Ctrl extends VoidControl | ValueControl> {
    /**
     * 控制循环流程
     */
    control?: Ctrl;
    value?: Row;
    key?: IDBValidKey;
    primaryKey?: IDBValidKey;
    /**
     * 保持为空时，不对修改结果进行保存
     */
    modify?: typeof Save | typeof Delete | null | undefined;
}
type VoidModifyFn<Row = any> = (value: Row, key: IDBValidKey, i: number) => void | IModifyResult<Row, VoidControl> | Promise<void | IModifyResult<Row, VoidControl>>;
type ValueModifyFn<Row = any, Rtn = any> = (value: Row, key: IDBValidKey, i: number, results: DbRecordResult<Rtn>[]) => void | IModifyResult<Row, ValueControl> | Promise<void | IModifyResult<Row, ValueControl>>;
interface ICursorArg<Row = any> extends ICursorOption {
    fn: VoidModifyFn<Row>;
}
interface ICursorResultArg<Row = any, Rtn = any> extends ICursorOption {
    fn: ValueModifyFn<Row, Rtn>;
    /**
     * 值为数组时，代表要返回的字段
     */
    mapper?: GetRowMapper<Rtn, Row> | string[] | undefined;
}
interface ICursorWriter<Row> {
    /**
     * 可写游标迭代器
     * - 如果需要只读游标，请使用`iterator()`
     * @param option
     */
    cursor(option?: ICursorOption): AsyncIterable<ICursorRow>;
    /**
     * 可写游标操作
     * - 如果需要只读游标，请使用`forEach()`
     * @param fn
     */
    cursor<Val extends Row = Row>(fn: VoidModifyFn<Val> | ICursorArg<Val>): Promise<void>;
    /**
     * 可写游标操作
     * - 如果需要只读游标，请使用`forEach()`
     * @param fn
     * @param returns
     */
    cursor<Rtn = DbRecordResult<Row>, Val extends Row = Row>(fn: ValueModifyFn<Val, Rtn> | ICursorResultArg<Val, Rtn>, returns: true): Promise<Rtn[]>;
}

interface IChangeRangeArg<Row> {
    newValue: Partial<Row>;
    /**
     * 用于确实影响范围
     * - 如果`record`中不含`key`值，则必须包含`query`
     * - 如果`query`与`record`中的`key`值同时，则优先使用`query`
     */
    query?: IDbQuery;
    /**
     * 游标滚动方向
     */
    direction?: IDBCursorDirection;
}
interface IRangeWriter<Row> {
    deleteRange(key: IDbQuery, returns?: false): Promise<void>;
    deleteRange(key: IDbQuery, returns: true): Promise<DbRecordResult<Row>[]>;
    deleteRange(key: IDbQuery, option: IDeleteOption<false | undefined>): Promise<void>;
    deleteRange(key: IDbQuery, option: IDeleteOption<true>): Promise<DbRecordResult<Row>[]>;
    deleteRangeMany(keys: IDbQuery[], returns?: false): Promise<void>;
    deleteRangeMany(keys: IDbQuery[], returns: true): Promise<DbRecordResult<Row>[][]>;
    deleteRangeMany(keys: IDbQuery[], option: IDeleteOption<false | undefined>): Promise<void>;
    deleteRangeMany(keys: IDbQuery[], option: IDeleteOption<true>): Promise<DbRecordResult<Row>[][]>;
    changeRange(arg: DbRecord<Partial<Row>> | IChangeRangeArg<Row>, returns?: false): Promise<void>;
    changeRange(arg: DbRecord<Partial<Row>> | IChangeRangeArg<Row>, returns: true): Promise<DbRecordResult<Row>[]>;
    changeRangeMany(args: DbRecord<Partial<Row>> | IChangeRangeArg<Row>[], returns?: false): Promise<void>;
    changeRangeMany(args: DbRecord<Partial<Row>> | IChangeRangeArg<Row>[], returns: true): Promise<DbRecordResult<Row>[][]>;
}

interface IChangeManyOption<Rtn extends boolean | undefined> {
    throwIfMissing?: boolean;
    returns?: Rtn;
}
interface IDeleteOption<Rtn extends boolean | undefined> {
    /**
     * 游标滚动方向，默认为`prev`
     */
    direction?: IDBCursorDirection;
    /**
     * 在设置了`softDeletedField`时，是否进行物理删除
     * - 如果值为`false`则仅使用`softDeletedField.name`进行标记
     */
    physical?: boolean;
    returns?: Rtn;
}
interface IDataWriter<Row = any, Tar extends OperationTarget = OperationTarget> extends IDataReader<Row, Tar>, ICursorWriter<Row>, IRangeWriter<Row> {
    /**
     * 原始的`IDBObjectStore`
     * - 仅当`target`为`NativeTarget`时有效
     */
    readonly nativeStore?: IDBObjectStore;
    add(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
    addMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
    addMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
    /**
     * 添加或跳过数据
     * - 将先检查`primaryKey`是否存在，再检查当前索引是否存在，如果皆不存在则添加，存在将返回存在的值
     * @param record
     */
    addOrSkip(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
    addOrSkipMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
    addOrSkipMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
    /**
     * 替换数据
     * @warning 仅针对`primaryKey`检查
     * - 如果未指定`primaryKey`或数据不存在时则为添加
     * @param record
     */
    replace(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
    replaceMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
    replaceMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
    /**
     * 修改数据
     * @warning 仅针对`primaryKey`检查
     * - 如果未指定`primaryKey`或数据不存在时则为跳过或抛出错误
     * @param record
     * @param throwIfMissing 未有`primaryKey`或数据不存在时, 值为`false`将抛出错误,值为`false`时返回`undefined`且不抛出错误
     */
    change(record: DbRecord<Partial<Row>>, throwIfMissing?: boolean): Promise<DbRecordResult<Row> | undefined>;
    changeMany(records: DbRecord<Partial<Row>>[], returns?: false): Promise<void>;
    changeMany(records: DbRecord<Partial<Row>>[], returns: true): Promise<(DbRecordResult<Row> | undefined)[]>;
    changeMany(records: DbRecord<Partial<Row>>[], option: IChangeManyOption<false | undefined>): Promise<void>;
    changeMany(records: DbRecord<Partial<Row>>[], option: IChangeManyOption<true>): Promise<(DbRecordResult<Row> | undefined)[]>;
    /**
     * 添加或修改数据
     * @warning 仅针对`primaryKey`检查
     * - 如果未指定`primaryKey`或数据不存在时则为添加
     * @param record
     */
    addOrChange(record: DbRecord<Partial<Row>>): Promise<DbRecordResult<Row> | undefined>;
    addOrChangeMany(records: DbRecord<Partial<Row>>[], returns?: false): Promise<void>;
    addOrChangeMany(records: DbRecord<Partial<Row>>[], returns: true): Promise<DbRecordResult<Row>[]>;
    /**
     * 删除数据
     * @warning 仅针对`primaryKey`检查
     * - 如果未指定`primaryKey`或数据不存在时则为添加
     * @param key
     * @param returns
     */
    delete(key: IDbQuery, returns?: false): Promise<void>;
    delete(key: IDbQuery, returns: true): Promise<DbRecordResult<Row>>;
    deleteMany(keys: IDbQuery[], returns?: false): Promise<void>;
    deleteMany(keys: IDbQuery[], returns: true): Promise<DbRecordResult<Row>[]>;
    /**
     * 批量写入
     * @param fn
     * @param rollbackOnError 当存在错误时是否回滚
     */
    batchWrite<R = any>(fn: (writer: IDataWriter<Row, NativeTarget>) => Promise<R | void>, rollbackOnError?: boolean): Promise<R>;
}
type NativeWriter<T = any> = IDataWriter<T, NativeTarget>;

interface IStoreUpgradeable<T = any> {
    readonly nativeStore: IDBObjectStore;
    readonly upgradeContext: IUpgradeContext;
    readonly storeSchema: IStoreSchema;
    add(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
    add(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>>;
    addOrChange(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
    addOrChange(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>[]>;
    replace(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
    replace(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>[]>;
    call<R = any>(versionBounds: IDbVersionBounds, fn: (store: IDataWriter, upgradeContext?: IUpgradeContext) => R | Promise<R>): Promise<R>;
}

interface IVersionValidateContext {
    readonly schema: Readonly<IDbSchema>;
    readonly db: IDBDatabase;
    readonly stores: IDBObjectStore[];
}

interface IDataOperationSchema {
    store: StoreSchema;
    index?: IndexSchema;
}
type DataOperationSchema = string | IDataOperationSchema;

/**
 * 默认值为`addOrChangeMany`
 */
type ImportUse = keyof Pick<IDataWriter, 'addMany' | 'addOrChangeMany' | 'replaceMany' | 'addOrSkipMany'>;
interface IMultiBackup {
    export(): Promise<Record<string, any[]>>;
    /**
     * @param data
     * @param returns
     * @param use 默认值为`addOrChangeMany`
     */
    import(data: Record<string, any[]>, returns?: false, use?: ImportUse): Promise<void>;
    /**
     * @param data
     * @param returns
     * @param use 默认值为`addOrChangeMany`
     */
    import(data: Record<string, any[]>, returns?: true, use?: ImportUse): Promise<Record<string, any[]>>;
}

interface IDataOperators<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any> extends IMultiBackup {
    read<Rtn = any>(fn: (s1: NativeReader<S1>, s2: NativeReader<S2>, s3: NativeReader<S3>, s4: NativeReader<S4>, s5: NativeReader<S5>, ...stores: NativeReader[]) => Rtn | Promise<Rtn>): Promise<Rtn>;
    write<Rtn = any>(fn: (s1: NativeWriter<S1>, s2: NativeWriter<S2>, s3: NativeWriter<S3>, s4: NativeWriter<S4>, s5: NativeWriter<S5>, ...stores: NativeWriter[]) => Rtn | Promise<Rtn>, rollbackOnError?: boolean): Promise<Rtn>;
}

interface IIDbPro extends IMultiBackup {
    readonly initialized: boolean;
    readonly schema: IDbSchema;
    readonly factory: IDataOperatorFactory;
    getStoreSchema(name: string): IStoreSchema;
    /**
     * 立即初始化所有定义
     * 一般不需要调用，仅用于开发时验证配置
     */
    initSchema(): IDbSchema;
    /**
     * 打开低层数据库
     * 仅在当前类库不能满足需求时使用
     */
    openNativeDb(): Promise<IDBDatabase>;
    /**
     * 定义`store`
     */
    store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema): RT;
    store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(operation: IDataOperationSchema): RT;
    store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema, index: IndexSchema): RT;
    /**
     * 定义多个`store`的联合
     */
    stores<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any, Rtn extends IDataOperators = IDataOperators<S1, S2, S3, S4, S5>>(schemas: DataOperationSchema[]): Rtn;
    /**
     * 定义一个数据会持久化到数据库的`map`，使用键值对存储，主要用于保存配置类信息
     * @param storeName 默认值为`idp-pro-map`
     * @param defaultData
     */
    map<K extends StrOrNum = StrOrNum, V = any>(storeName?: string, defaultData?: RequiredDbNoneKeyPathRecord<V, K>[]): IDbMap<K, V, IInfoTarget>;
    /**
     * 定义一个数据会持久化到数据库的`map`，使用键值对存储，主要用于保存配置类信息
     * @param storeName 默认值为`idp-pro-map`
     * @param defaultData
     */
    map<K extends StrOrNum = StrOrNum, V = any>(defaultData?: RequiredDbNoneKeyPathRecord<V, K>[], storeName?: string): IDbMap<K, V, IInfoTarget>;
    /**
     * 向命令行输出当前配置
     * @param showFn 是否输出函数
     */
    traceSchema(showFn?: boolean): void | Promise<void>;
}

interface IDataOperatorFactory {
    newDbMap?<T extends IDbMap>(schema: IValidDataOperationSchema<any>, db?: IIDbPro): T;
    newReader?<T extends IDataReader>(schema: IValidDataOperationSchema<any>, db?: IIDbPro): T;
    newWriter?<T extends IDataWriter>(schema: IValidDataOperationSchema<any>, db?: IIDbPro): T;
    newDataOperators?<T extends IDataOperators>(schemas: IValidDataOperationSchema<IInfoTarget>[], db: IIDbPro): T;
    newStoreUpgradeable?<T extends IStoreUpgradeable>(nativeStore: IDBObjectStore, storeSchema: IStoreSchema, upgradeContext: IUpgradeContext): T;
}

type VersionValidateFn = (context: IVersionValidateContext) => true | string | Promise<true | string>;
interface IDbSchema {
    name: string;
    /**
     * 默认值为1
     */
    version?: number;
    /**
     * 用于定义`storeSchemas` 默认值的模板
     */
    storeTemplate?: IStoreSchemaTemplate;
    storeSchemas?: StoreSchema[];
    /**
     * 当 `schema` 与 `db` 版本不同时，的检测器
     * - 默认值为 `true`
     * - 如果为 `false`，则不会检测
     * - 如果为函数，将使用自定义检测器
     */
    versionDiffValidate?: boolean | VersionValidateFn;
    /**
     * 当 `schema` 与 `db` 版本相同时的检测器
     * - 默认值为 `true`
     * - 如果为 `false`，则不会检测
     * - 如果为函数，将使用自定义检测器
     */
    versionSameValidate?: boolean | VersionValidateFn;
    /**
     * 创建或升级前执行
     * 通常用于重新定义store前删除同名store
     */
    beforeUpgrade?: (context: IUpgradeContext) => Promise<void>;
    /**
     * 创建或升级后执行
     * 通常用于升级了store结构后对旧数据进行升级
     */
    afterUpgrade?: (context: IUpgradeContext) => Promise<void>;
    /**
     * 用于对 schema 检测并赋予默认值
     * 对于小部分自定义默认值时，可以先调用`validateSchemaWithDefaults()`再进行自定义部分处理
     * @param schema
     */
    validateSchemaWithDefaults?: (schema: IDbSchema) => IDbSchema;
    /**
     * 数据操作器工厂
     */
    factory?: IDataOperatorFactory;
}
type DBSchema = string | IDbSchema;

interface IDbVersionBounds {
    oldMin?: number;
    oldMax?: number;
    newMin?: number;
    newMax?: number;
}
interface IUpgradeContextArgs {
    readonly newVersion: number;
    readonly oldVersion: number;
    readonly dbSchema: Readonly<IDbSchema>;
    readonly database: IDBDatabase;
    readonly transaction: IDBTransaction;
}
interface IUpgradeContext extends IUpgradeContextArgs, IDisposable {
    store<T = any>(storeName: string): IStoreUpgradeable<T>;
    deleteStoreIfExists(storeName: string): void;
    versionIn(bounds: IDbVersionBounds): boolean;
}

interface IDbNoneKeyPathRecord<T = any, K = IDBValidKey> {
    key?: K;
    value: T;
}
/**
 * 当前`store`不存在`KeyPath`时，用于一行数据记录的表示
 * - 当使用数组时,`key`为数组第二项，`value`为数组第一项
 * - `value`必须存在值，`key`值可选
 */
type DbNoneKeyPathRecord<V = any, K extends IDBValidKey = IDBValidKey> = IDbNoneKeyPathRecord<V, K> | [V, K?];
type RequiredDbNoneKeyPathRecord<V = any, K extends IDBValidKey = IDBValidKey> = Required<IDbNoneKeyPathRecord<V, K>> | [V, K];
type ArrayDbRecord<V = any, K extends IDBValidKey = IDBValidKey> = [V, K?] | V;
type DbRecord<V = any, K extends IDBValidKey = IDBValidKey> = DbNoneKeyPathRecord<V, K> | V;
type DbRecordResult<V = any, K = IDBValidKey> = Required<IDbNoneKeyPathRecord<V, K>> | V;
interface IVersionData {
    /**
     * 满足更新数据的版本范围
     */
    version: IDbVersionBounds;
    /**
     * 需要更新的数据记录
     */
    data: DbRecord[];
    /**
     * 用于添加数据的方法，默认为`addOrChange`
     */
    use?: keyof Pick<IStoreUpgradeable, 'add' | 'addOrChange' | 'replace'>;
}
declare function parseDbNoneKeyPathRecord<T = any, K extends IDBValidKey = IDBValidKey>(record: any): Required<IDbNoneKeyPathRecord<T, K>>;

type FindFn<T> = (value: T, primaryKey: IDBValidKey, index: number) => boolean | void | Promise<boolean | void>;
/**
 * @template V 原始`store`一行数据的类型
 */
interface IFindArg<V = any> extends ICursorOption {
    fn?: FindFn<V> | undefined;
    /**
     * 最多查找次数,默认值为20000
     */
    maxEmptyChecks?: number;
}
/**
 * @template R 在有`mapper`时返回值的类型
 * @template V 原始`store`一行数据的类型
 */
interface IFindMapArg<R = any, V = any> extends IFindArg<V> {
    /**
     * 值为数组时，代表要返回的字段
     */
    mapper?: GetRowMapper<R, V> | string[] | undefined;
}
/**
 * @template R 在有`mapper`时返回值的类型
 * @template V 原始`store`一行数据的类型
 */
interface IFilterArg<R = any, V = any> extends IFindMapArg<R, V> {
    /**
     * 最多返回记录数,默认值为1000
     */
    limit?: number;
}
interface ICursorQueryable<Row> {
    count(): Promise<number>;
    count(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<number>;
    count(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<number>;
    count(arg: IFindArg<Row>): Promise<number>;
    getRange(key: IDbQuery, direction?: IDBCursorDirection): Promise<DbRecordResult<Row>[]>;
    getRangeMany(keys: IDbQuery[], direction?: IDBCursorDirection): Promise<DbRecordResult<Row>[]>;
    find(): Promise<Row | undefined>;
    find(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row> | undefined>;
    find(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row> | undefined>;
    find<R = ArrayDbRecord<Row>>(args: IFindMapArg<R, Row>): Promise<Row | undefined>;
    filter(): Promise<Row[]>;
    filter<R = ArrayDbRecord<Row>>(args: IFilterArg<R, Row>): Promise<Row[]>;
    filter(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row>[]>;
    filter(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row>[]>;
    export<R = ArrayDbRecord<Row>>(): Promise<ArrayDbRecord<R>[]>;
    export<R = ArrayDbRecord<Row>>(query: IDbQuery | FindFn<Row>): Promise<ArrayDbRecord<R>[]>;
    export<R = ArrayDbRecord<Row>>(query: IDbQuery, fn: FindFn<Row>): Promise<ArrayDbRecord<R>[]>;
}

type ReadCallFn<T> = (target: NativeTarget) => T | undefined | Promise<T | undefined>;
type WriteCallFn<T> = (target: NativeTarget, store: IDBObjectStore) => T | undefined | Promise<T | undefined>;
interface INativeOperationResult<T extends NativeTarget> {
    readonly db?: IDBDatabase;
    readonly tx?: IDBTransaction;
    readonly nativeStore?: IDBObjectStore;
    readonly target: T;
}

type ExportDataTo = keyof Pick<IStoreSchema, 'defaultData' | 'versionData'>;
declare const defaultSpecialFields: Readonly<ISpecialFields>;
interface IGenerateOption<Ts extends boolean | number | undefined> {
    /**
     * 用于确定特殊索引的字段，未定义则使用`defaultSpecialFields`
     */
    specialFields?: ISpecialFields;
    /**
     * 用于定义导出数据的位置，未定义则不导出数据
     */
    dataExportTarget?: ExportDataTo;
    /**
     * 是否输出为字符串
     * - 为`true`时输出为代码最小换行为`160`字符串，否则为`IDbSchema`对象
     * - 为数字时为输出代码最小换行长度,如果小于1，则会使用`1`
     */
    asString?: Ts;
}

interface IOpenCursorArg extends ICursorOption {
    fn: (cursor: IDBCursorWithValue) => void | false | Promise<void | false>;
}
declare class DataOperationBase implements IValidDataOperationSchema<any>, IForEachable {
    #private;
    readonly idbPro?: IIDbPro;
    readonly target: any;
    constructor(schema: IValidDataOperationSchema<any>, db?: IIDbPro);
    get storeName(): string;
    get storeSchema(): IStoreSchema;
    get factory(): IDataOperatorFactory;
    get nativeStore(): IDBObjectStore | undefined;
    get keyPath(): string | string[] | null | undefined;
    forEach<T = any>(fn: VoidCallFn<T> | IForEachArg<T>): Promise<void>;
    forEach<R = DbRecordResult, T = any>(fn: ValueCallFn<T, R> | IForEachResultArg<T, R>, returns: true): Promise<R[]>;
    protected tx(writable?: false): Promise<INativeOperationResult<NativeTarget>>;
    protected tx(writable: true): Promise<INativeOperationResult<IDBObjectStore>>;
    protected tx<T>(fn: ReadCallFn<T>): Promise<T>;
    protected tx<T>(writable: false, fn?: ReadCallFn<T>): Promise<T>;
    protected tx<T>(writable: true, fn?: WriteCallFn<T>, rollbackOnError?: boolean): Promise<T>;
    protected openCursor(arg: IOpenCursorArg, writable?: boolean): Promise<void>;
    protected cursorVoid({ query, direction, preSkip, startKey, startPrimaryKey, fn }: ICursorArg, writable: boolean): Promise<void>;
    protected cursorResult({ query, direction, preSkip, startKey, startPrimaryKey, fn, mapper: mpr }: ICursorResultArg, writable: boolean): Promise<any>;
}

declare class DataOperators<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any> implements IDataOperators<S1, S2, S3, S4, S5> {
    #private;
    readonly idbPro: IIDbPro;
    readonly schemas: IValidDataOperationSchema<IInfoTarget>[];
    constructor(idbPro: IIDbPro, schemas: IValidDataOperationSchema<IInfoTarget>[]);
    get storeNames(): string[];
    read<Rtn = any>(fn: (s1: NativeReader<S1>, s2: NativeReader<S2>, s3: NativeReader<S3>, s4: NativeReader<S4>, s5: NativeReader<S5>, ...stores: NativeReader[]) => (Promise<Rtn> | Rtn)): Promise<Rtn>;
    write<Rtn = any>(fn: (s1: NativeWriter<S1>, s2: NativeWriter<S2>, s3: NativeWriter<S3>, s4: NativeWriter<S4>, s5: NativeWriter<S5>, ...stores: NativeWriter[]) => (Promise<Rtn> | Rtn), rollbackOnError?: boolean): Promise<Rtn>;
    export(): Promise<Record<string, any[]>>;
    import(data: Record<string, any[]>, returns?: false, use?: ImportUse): Promise<void>;
    import(data: Record<string, any[]>, returns?: true, use?: ImportUse): Promise<Record<string, any[]>>;
    protected tx(method: keyof Pick<IDataOperatorFactory, 'newReader' | 'newWriter'>, fn: Function, writable?: boolean, rollbackOnError?: boolean): Promise<any>;
}

declare class DataReader<Row, Tar extends OperationTarget = OperationTarget> extends DataOperationBase implements IDataReader<Row, Tar> {
    all(query?: IDbQuery, limit?: number): Promise<Row[]>;
    all(args?: IGetAllArgs<Row>): Promise<Row[]>;
    count(): Promise<number>;
    count(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<number>;
    count(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<number>;
    count(arg: IFindArg<Row>): Promise<number>;
    get(key: IDbQuery): Promise<Row | undefined>;
    getMany(keys: IDbQuery[], excludeEmpty?: boolean): Promise<Row[]>;
    getRange(query: IDbQuery, direction?: IDBCursorDirection): Promise<DbRecordResult<Row>[]>;
    getRangeMany(keys: IDbQuery[], direction?: IDBCursorDirection): Promise<DbRecordResult<Row>[]>;
    index(name: string): IDataReader<Row, Tar>;
    index(name: string, writable: true): IDataWriter<Row, Tar>;
    asStore(): IDataReader<Row, Tar>;
    asStore(writable: true): IDataWriter<Row, Tar>;
    batchRead<R = any>(fn: (reader: IDataReader<Row, NativeTarget>) => Promise<void | R>): Promise<R>;
    iterator(query: IDbQuery, direction?: IDBCursorDirection): AsyncIterable<Row>;
    iterator(arg: IDbIteratorArg): AsyncIterable<Row>;
    filter(): Promise<Row[]>;
    filter<R = ArrayDbRecord<Row>>(args: IFilterArg<R, Row>): Promise<R[]>;
    filter(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row>[]>;
    filter(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row>[]>;
    filter(arg1?: IDbQuery | FindFn<Row> | IFilterArg<Row>, arg2?: IDBCursorDirection | FindFn<Row>, arg3?: IDBCursorDirection, limit?: number): Promise<ArrayDbRecord<Row>[]>;
    find(): Promise<Row | undefined>;
    find(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row> | undefined>;
    find(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row> | undefined>;
    find<R = ArrayDbRecord<Row>>(args: IFindMapArg<R, Row>): Promise<Row | undefined>;
    page<R = ArrayDbRecord<Row>>(): Promise<IPage<R, Row>>;
    page<R = ArrayDbRecord<Row>>(arg: IPageArg<R, Row> | IPageInfo<R, Row>, page?: number): Promise<IPage<R, Row>>;
    nextPage<R = Row>(info: IPageInfo<R, Row>): Promise<IPage<R, Row>>;
    export<R = ArrayDbRecord<Row>>(): Promise<ArrayDbRecord<R>[]>;
    export<R = ArrayDbRecord<Row>>(query: IDbQuery | FindFn<Row>): Promise<ArrayDbRecord<R>[]>;
    export<R = ArrayDbRecord<Row>>(query: IDbQuery, fn: FindFn<Row>): Promise<ArrayDbRecord<R>[]>;
    asMap<Key extends StrOrNum = StrOrNum>(): IDbMap<Key, Row, Tar>;
    protected createOperator(target: OperationTarget, writable?: boolean): any;
}

declare class DataWriter<Row, Tar extends OperationTarget = OperationTarget> extends DataReader<Row, Tar> implements IDataWriter<Row, Tar> {
    add(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
    addMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
    addMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
    addOrSkip(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
    addOrSkipMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
    addOrSkipMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
    replace(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
    replaceMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
    replaceMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
    change(record: DbRecord<Partial<Row>>, throwIfMissing?: boolean): Promise<DbRecordResult<Row> | undefined>;
    changeMany(records: DbRecord<Partial<Row>>[], returns?: false): Promise<void>;
    changeMany(records: DbRecord<Partial<Row>>[], returns: true): Promise<(DbRecordResult<Row> | undefined)[]>;
    changeMany(records: DbRecord<Partial<Row>>[], option: IChangeManyOption<false | undefined>): Promise<void>;
    changeMany(records: DbRecord<Partial<Row>>[], option: IChangeManyOption<true>): Promise<(DbRecordResult<Row> | undefined)[]>;
    addOrChange(record: DbRecord<Partial<Row>>): Promise<DbRecordResult<Row> | undefined>;
    addOrChangeMany(records: DbRecord<Partial<Row>>[], returns?: false): Promise<void>;
    addOrChangeMany(records: DbRecord<Partial<Row>>[], returns: true): Promise<DbRecordResult<Row>[]>;
    delete(key: IDbQuery, returns?: false): Promise<void>;
    delete(key: IDbQuery, returns: true): Promise<DbRecordResult<Row>>;
    deleteMany(keys: IDbQuery[], returns?: false): Promise<void>;
    deleteMany(keys: IDbQuery[], returns: true): Promise<DbRecordResult<Row>[]>;
    deleteRange(key: IDbQuery, returns?: false): Promise<void>;
    deleteRange(key: IDbQuery, returns: true): Promise<DbRecordResult<Row>[]>;
    deleteRange(key: IDbQuery, option: IDeleteOption<false | undefined>): Promise<void>;
    deleteRange(key: IDbQuery, option: IDeleteOption<true>): Promise<DbRecordResult<Row>[]>;
    deleteRangeMany(keys: IDbQuery[], returns?: false): Promise<void>;
    deleteRangeMany(keys: IDbQuery[], returns: true): Promise<DbRecordResult<Row>[][]>;
    deleteRangeMany(keys: IDbQuery[], option: IDeleteOption<false | undefined>): Promise<void>;
    deleteRangeMany(keys: IDbQuery[], option: IDeleteOption<true>): Promise<DbRecordResult<Row>[][]>;
    changeRange(arg: DbRecord<Partial<Row>> | IChangeRangeArg<Row>, returns?: false): Promise<void>;
    changeRange(arg: DbRecord<Partial<Row>> | IChangeRangeArg<Row>, returns: true): Promise<DbRecordResult<Row>[]>;
    changeRangeMany(args: DbRecord<Partial<Row>> | IChangeRangeArg<Row>[], returns?: false): Promise<void>;
    changeRangeMany(args: DbRecord<Partial<Row>> | IChangeRangeArg<Row>[], returns: true): Promise<DbRecordResult<Row>[][]>;
    cursor(option?: ICursorOption): AsyncIterable<ICursorRow>;
    cursor<Val extends Row = Row>(fn: VoidModifyFn<Val> | ICursorArg<Val>): Promise<void>;
    cursor<Rtn = DbRecordResult<Row>, Val extends Row = Row>(fn: ValueModifyFn<Val, Rtn> | ICursorResultArg<Val, Rtn>, returns: true): Promise<Rtn[]>;
    batchWrite<R = any>(fn: (writer: IDataWriter<Row, NativeTarget>) => Promise<void | R>, rollbackOnError?: boolean): Promise<R>;
    protected changeByPk({ pk, record, fn, requiredPk, getOld, requiredOld, saveMapper, getMapper }: {
        pk?: IDbQuery;
        record?: DbRecord<Partial<Row>>;
        fn: (store: IDBObjectStore, pk: DbQuery, newValue: any, oldValue: any, keyPath?: string | string[]) => void | [Row, DbQuery?] | Promise<void | [Row, DbQuery?]>;
        requiredPk?: boolean;
        getOld?: boolean;
        requiredOld?: boolean;
        saveMapper?: SaveRowMapper<any, any>;
        getMapper?: GetRowMapper<any, any>;
    }): any;
}

declare class DbIterator<T> extends DataOperationBase implements IDbIterator<T> {
    direction: IDBCursorDirection;
    query: IDbQuery;
    writable: boolean;
    parser: IDbIteratorParser;
    endsWithNull: boolean;
    preSkip?: number;
    startKey?: IDBValidKey;
    startPrimaryKey?: IDBValidKey;
    constructor(schema: IValidDataOperationSchema<any>, db?: IIDbPro, option?: IDbIteratorOption<T>);
    [Symbol.asyncIterator](): AsyncIterator<T>;
}

declare class DbMap<K extends StrOrNum = StrOrNum, V = any, Tar extends OperationTarget = OperationTarget> extends DataOperationBase implements IDbMap<K, V, Tar> {
    get size(): Promise<number>;
    delete(key: K): Promise<void>;
    batch<R = any, T extends V = V>(fn: (map: IDbMap<K, T, NativeTarget>) => (Promise<R> | R)): Promise<R>;
    asStore(): IDataReader<V, Tar>;
    asStore(writable: true): IDataWriter<V, Tar>;
    entries<T extends V = V>(): AsyncIterable<[K, T]>;
    get<T extends V = V>(key: K, defaultValue?: T): Promise<T | undefined>;
    getMany<T extends V = V>(keys: K[]): Promise<(T | undefined)[]>;
    has(key: K): Promise<boolean>;
    keys(): AsyncIterable<K>;
    set<T extends V = V>(key: K, value: T): Promise<void>;
    setMany<T extends V = V>(values: [K, V][]): Promise<void>;
    values<T extends V = V>(): AsyncIterable<T>;
}

declare function dbStore<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(schema: StoreSchema): RT;
declare function dbStore<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(schema: IDataOperationSchema): RT;
declare function dbStore<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema, index: IndexSchema): RT;
declare function dbMap<K extends StrOrNum = StrOrNum, V = any>(storeName?: string, defaultData?: RequiredDbNoneKeyPathRecord<V, K>[]): IDbMap<K, V, IInfoTarget>;
declare function dbMap<K extends StrOrNum = StrOrNum, V = any>(defaultData?: RequiredDbNoneKeyPathRecord<V, K>[], storeName?: string): IDbMap<K, V, IInfoTarget>;
declare function dbStores<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any, Rtn extends IDataOperators = IDataOperators<S1, S2, S3, S4, S5>>(schemas: DataOperationSchema[]): Rtn;
/**
 * 释放默认数据库实例（如果存在）
 */
declare function releaseDefaultDB(): void;

declare class IDbPro implements IIDbPro {
    #private;
    constructor(schema: DBSchema, skipPreOpenValidation?: true);
    /**
     * 默认实例
     */
    static get defaultDb(): IIDbPro;
    get initialized(): boolean;
    get schema(): IDbSchema;
    get storeNames(): string[];
    get factory(): IDataOperatorFactory;
    /**
     * 释放默认数据库实例（如果存在）
     */
    static releaseDefaultDB(): void;
    /**
     * 从已经存在的`name`数据库中打开
     * @warning 该方法仅用于不需要修改原有数据库结构的场景
     * - 如果需要修改，请使用 `generateDbSchema()` 从现有数据库生成配置，且适当修改后重新打开
     * @param name
     */
    static openExistDb(name: string): Promise<IIDbPro>;
    static store<T = any, RT extends IDataWriter<T> = IDataWriter<T>>(store: StoreSchema): RT;
    static store<T = any, RT extends IDataWriter<T> = IDataWriter<T>>(operation: IDataOperationSchema): RT;
    static store<T = any, RT extends IDataWriter<T> = IDataWriter<T>>(store: StoreSchema, index: IndexSchema): RT;
    static stores<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any, Rtn extends IDataOperators = IDataOperators<S1, S2, S3, S4, S5>>(schemas: DataOperationSchema[]): IDataOperators<Rtn>;
    static map<K extends StrOrNum = StrOrNum, V = any>(storeName?: string, defaultData?: (IDbNoneKeyPathRecord<V, K> | [V, K])[]): IDbMap<K, V, IInfoTarget>;
    static map<K extends StrOrNum = StrOrNum, V = any>(defaultData?: (IDbNoneKeyPathRecord<V, K> | [V, K])[], storeName?: string): IDbMap<K, V, IInfoTarget>;
    openNativeDb(): Promise<IDBDatabase>;
    store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema): RT;
    store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(operation: IDataOperationSchema): RT;
    store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema, index: IndexSchema): RT;
    stores<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any, Rtn extends IDataOperators = IDataOperators<S1, S2, S3, S4, S5>>(schemas: DataOperationSchema[]): Rtn;
    initSchema(): IDbSchema;
    traceSchema(showFn?: boolean): Promise<void>;
    map<K extends StrOrNum = StrOrNum, V = any>(storeName?: string, defaultData?: RequiredDbNoneKeyPathRecord<V, K>[]): IDbMap<K, V, IInfoTarget>;
    map<K extends StrOrNum = StrOrNum, V = any>(defaultData?: RequiredDbNoneKeyPathRecord<V, K>[], storeName?: string): IDbMap<K, V, IInfoTarget>;
    export(): Promise<Record<string, any[]>>;
    import(data: Record<string, any[]>, returns?: false, use?: ImportUse): Promise<void>;
    import(data: Record<string, any[]>, returns?: true, use?: ImportUse): Promise<Record<string, any[]>>;
    getStoreSchema(name: string): IStoreSchema;
}

declare function parseIDbQuery(query: IDbQuery | IDBKeyRange | undefined | null): IDBValidKey | IDBKeyRange | null | undefined;
declare function isIDbQuery(query: any): boolean;

declare class StoreUpgradeable<T = any> implements IStoreUpgradeable<T> {
    #private;
    readonly upgradeContext: IUpgradeContext;
    readonly storeSchema: IStoreSchema;
    readonly nativeStore: IDBObjectStore;
    constructor(upgradeContext: IUpgradeContext, storeSchema: IStoreSchema, nativeStore: IDBObjectStore);
    get writer(): IDataWriter<T>;
    add(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
    add(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>>;
    addOrChange(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
    addOrChange(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>[]>;
    call<R = any>(versionBounds: IDbVersionBounds, fn: (store: IDataWriter, upgradeContext?: IUpgradeContext) => (Promise<R> | R)): Promise<R>;
    replace(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
    replace(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>[]>;
}

declare class UpgradeContext implements IUpgradeContext {
    #private;
    readonly database: IDBDatabase;
    readonly newVersion: number;
    readonly oldVersion: number;
    readonly dbSchema: Readonly<IDbSchema>;
    readonly transaction: IDBTransaction;
    constructor(args: IUpgradeContextArgs);
    deleteStoreIfExists(storeName: string): void;
    destroy(): void;
    store<T = any>(storeName: string): IStoreUpgradeable<T>;
    versionIn({ oldMin, oldMax, newMax, newMin }: IDbVersionBounds): boolean;
}

declare const validateSchemaWithDefaults: IDbSchema['validateSchemaWithDefaults'];

/**
 * 版本差异验证器
 * @param context
 */
declare const versionDiffValidate: VersionValidateFn;

declare const versionSameValidate: VersionValidateFn;

declare function generateDbSchema(db: string, option?: IGenerateOption<undefined | false>): Promise<IDbSchema>;
declare function generateDbSchema(db: string, option: IGenerateOption<true | number>): Promise<string>;

export { Break, Continue, ContinueKey, ContinuePrimaryKey, DataOperationBase, DataOperators, DataReader, DataWriter, DbIterator, DbIteratorParsers, DbMap, Delete, Finished, IDbPro, NextKey, NextPrimaryKey, Save, StoreUpgradeable, UpgradeContext, dbMap, dbStore, dbStores, defaultSpecialFields, defaultStoreSchemaTemplate, generateDbSchema, isIDbQuery, isNativeTarget, parseDbNoneKeyPathRecord, parseIDbQuery, releaseDefaultDB, validateSchemaWithDefaults, versionDiffValidate, versionSameValidate };
export type { ArrayDbRecord, DBSchema, DataOperationSchema, DbIteratorParsersKey, DbNoneKeyPathRecord, DbRecord, DbRecordResult, ExportDataTo, FindFn, GetRowMapper, IChangeManyOption, IChangeRangeArg, ICursorArg, ICursorOption, ICursorQueryable, ICursorReader, ICursorResultArg, ICursorRow, ICursorWriter, IDataOperationSchema, IDataOperatorFactory, IDataOperators, IDataReader, IDataWriter, IDbGtRange, IDbGteRange, IDbIterator, IDbIteratorArg, IDbIteratorOption, IDbIteratorParser, IDbLtGtRange, IDbLtGteRange, IDbLtRange, IDbLteGtRange, IDbLteGteRange, IDbLteRange, IDbMap, IDbNoneKeyPathRecord, IDbQuery, IDbRange, IDbSchema, IDbVersionBounds, IDeleteOption, IFilterArg, IFindArg, IFindMapArg, IForEachArg, IForEachResultArg, IForEachable, IGenerateOption, IGetAllArgs, IIDbPro, IIndexSchema, IInfoTarget, IModifyResult, IMultiBackup, INativeOperationResult, IOpenCursorArg, IPage, IPageArg, IPageInfo, IPageableQuery, IRangeWriter, ISpecialFieldSchema, ISpecialFields, IStoreSchema, IStoreSchemaTemplate, IStoreUpgradeable, IUpgradeContext, IUpgradeContextArgs, IValidDataOperationSchema, IValueResult, IVersionData, IVersionValidateContext, IVoidResult, ImportUse, IndexSchema, NativeReader, NativeTarget, NativeWriter, OperationTarget, ReadCallFn, RequiredDbNoneKeyPathRecord, SaveRowMapper, SpecialFieldSchema, StoreSchema, ValueCallFn, ValueControl, ValueModifyFn, VersionValidateFn, VoidCallFn, VoidControl, VoidModifyFn, VoidResult, WriteCallFn };