gs-idb-pro 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,1118 @@
+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 };