import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearchOption, BPTreeUnknownNode, SerializableData, IBPTree } from './types';
import { SerializeStrategySync } from './SerializeStrategySync';
import { ValueComparator } from './base/ValueComparator';
import { BPTreeTransaction } from './base/BPTreeTransaction';
export declare class BPTreePureSync<K, V> implements IBPTree<K, V> {
    protected readonly strategy: SerializeStrategySync<K, V>;
    protected readonly comparator: ValueComparator<V>;
    protected readonly option: BPTreeConstructorOption;
    private readonly _cachedRegexp;
    private readonly _verifierMap;
    private readonly _searchConfigs;
    constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
    private _ensureValues;
    private _createReadOps;
    private _createBufferedOps;
    private _readCtx;
    private _createCtx;
    init(): void;
    getRootNode(): BPTreeUnknownNode<K, V>;
    getRootId(): string;
    getOrder(): number;
    verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
    get(key: K): V | undefined;
    exists(key: K, value: V): boolean;
    keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<K>;
    whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<[K, V]>;
    keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Set<K>;
    where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): BPTreePair<K, V>;
    insert(key: K, value: V): void;
    delete(key: K, value?: V): void;
    batchDelete(entries: [K, V?][]): void;
    batchInsert(entries: [K, V][]): void;
    bulkLoad(entries: [K, V][]): void;
    getHeadData(): SerializableData;
    setHeadData(data: SerializableData): void;
    static ChooseDriver: typeof BPTreeTransaction.ChooseDriver;
}