import type { TransactionEntry, TransactionResult } from 'mvcc-api';
import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData, BPTreeNode, BPTreeMVCC, BPTreeSearchOption, IBPTree } from '../types';
import { ValueComparator } from './ValueComparator';
import { SerializeStrategy } from './SerializeStrategy';
export declare abstract class BPTreeTransaction<K, V> implements IBPTree<K, V> {
    protected readonly _cachedRegexp: Map<string, RegExp>;
    protected readonly rootTx: BPTreeTransaction<K, V>;
    protected readonly mvccRoot: BPTreeMVCC<K, V>;
    protected readonly mvcc: BPTreeMVCC<K, V>;
    protected readonly strategy: SerializeStrategy<K, V>;
    protected readonly comparator: ValueComparator<V>;
    protected readonly option: BPTreeConstructorOption;
    protected order: number;
    protected rootId: string;
    protected isInitialized: boolean;
    protected isDestroyed: boolean;
    protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>;
    protected readonly searchConfigs: Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', {
        start: (tx: BPTreeTransaction<K, V>, v: V[]) => Deferred<BPTreeLeafNode<K, V> | null>;
        end: (tx: BPTreeTransaction<K, V>, v: V[]) => Deferred<BPTreeLeafNode<K, V> | null>;
        direction: 1 | -1;
        earlyTerminate: boolean;
    }>>;
    /**
     * Priority map for condition types.
     * Higher value = higher selectivity (fewer expected results).
     * Used by `chooseDriver` to select the most selective index.
     */
    protected static readonly conditionPriority: Record<keyof BPTreeCondition<unknown>, number>;
    /**
     * Selects the best driver tree from multiple tree/condition pairs.
     * Uses rule-based optimization to choose the tree with highest estimated selectivity.
     *
     * @param candidates Array of { tree, condition } pairs to evaluate
     * @returns The candidate with highest priority condition, or null if empty
     *
     * @example
     * ```typescript
     * const driver = BPTreeSync.chooseDriver([
     *   { tree: idxId, condition: { equal: 100 } },
     *   { tree: idxAge, condition: { gt: 20 } }
     * ])
     * // Returns { tree: idxId, condition: { equal: 100 } } because 'equal' has higher priority
     * ```
     */
    static ChooseDriver<T>(candidates: Array<{
        tree: T;
        condition: BPTreeCondition<unknown>;
    }>): {
        tree: T;
        condition: BPTreeCondition<unknown>;
    } | null;
    /**
     * Checks for conflicts between multiple transactions.
     *
     * @param transactions Array of BPTreeTransaction instances to check
     * @returns An array of keys that are in conflict. Empty array if no conflicts.
     */
    static CheckConflicts<K, V>(transactions: BPTreeTransaction<K, V>[]): string[];
    abstract getRootNode(): Deferred<BPTreeUnknownNode<K, V>>;
    getRootId(): string;
    getOrder(): number;
    verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
    /**
     * Inserts a key-value pair into an already-cloned leaf node in-place.
     * Unlike _insertAtLeaf, this does NOT clone or update the node via MVCC.
     * Used by batchInsert to batch multiple insertions with a single clone/update.
     * @returns true if the leaf was modified, false if the key already exists.
     */
    protected _insertValueIntoLeaf(leaf: BPTreeLeafNode<K, V>, key: K, value: V): boolean;
    protected _cloneNode<T extends BPTreeUnknownNode<K, V>>(node: T): T;
    /**
     * Resolves the best start/end configuration by independently examining
     * all conditions. Selects the tightest lower bound for start and the
     * tightest upper bound for end (in asc; reversed for desc).
     *
     * @param condition The condition to analyze.
     * @param order The sort order ('asc' or 'desc').
     * @returns The resolved start/end keys, values, and traversal direction.
     */
    resolveStartEndConfigs(condition: BPTreeCondition<V>, order: 'asc' | 'desc'): {
        startKey: keyof BPTreeCondition<V> | null;
        endKey: keyof BPTreeCondition<V> | null;
        startValues: V[];
        endValues: V[];
        direction: 1 | -1;
    };
    private static readonly _lowerBoundKeys;
    private static readonly _upperBoundKeys;
    private static readonly _multiValueKeys;
    protected constructor(rootTx: BPTreeTransaction<K, V> | null, mvccRoot: BPTreeMVCC<K, V>, mvcc: BPTreeMVCC<K, V>, strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
    protected abstract _createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): Deferred<BPTreeUnknownNode<K, V>>;
    protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Deferred<BPTreeUnknownNode<K, V>>;
    protected abstract _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Deferred<void>;
    protected abstract _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<BPTreeUnknownNode<K, V>>;
    protected abstract getNode(id: string): Deferred<BPTreeUnknownNode<K, V>>;
    protected abstract locateLeaf(value: V): Deferred<BPTreeLeafNode<K, V>>;
    protected abstract findLowerBoundLeaf(value: V): Deferred<BPTreeLeafNode<K, V>>;
    protected abstract findUpperBoundLeaf(value: V): Deferred<BPTreeLeafNode<K, V>>;
    protected abstract findOuterBoundaryLeaf(value: V, direction: 1 | -1): Deferred<BPTreeLeafNode<K, V> | null>;
    protected abstract leftestNode(): Deferred<BPTreeLeafNode<K, V>>;
    protected abstract rightestNode(): Deferred<BPTreeLeafNode<K, V>>;
    abstract init(): Deferred<void>;
    abstract reload(): Deferred<void>;
    abstract get(key: K): Deferred<V | undefined>;
    abstract keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<K> | Generator<K>;
    abstract whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<[K, V]> | Generator<[K, V]>;
    abstract keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Deferred<Set<K>>;
    abstract where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Deferred<BPTreePair<K, V>>;
    abstract insert(key: K, value: V): Deferred<void>;
    abstract batchInsert(entries: [K, V][]): Deferred<void>;
    abstract bulkLoad(entries: [K, V][]): Deferred<void>;
    abstract delete(key: K, value?: V): Deferred<void>;
    abstract batchDelete(entries: [K, V?][]): Deferred<void>;
    abstract exists(key: K, value: V): Deferred<boolean>;
    abstract setHeadData(data: SerializableData): Deferred<void>;
    abstract getHeadData(): Deferred<SerializableData>;
    /**
     * Commits the transaction and returns the result.
     * @param label The label of the transaction.
     */
    abstract commit(label?: string): Deferred<TransactionResult<string, BPTreeNode<K, V>>>;
    /**
     * Rolls back the transaction and returns the result.
     */
    abstract rollback(): Deferred<TransactionResult<string, BPTreeNode<K, V>>>;
    protected ensureValues(v: V | V[]): V[];
    protected lowestValue(v: V[]): V;
    protected highestValue(v: V[]): V;
    protected lowestPrimaryValue(v: V[]): V;
    protected highestPrimaryValue(v: V[]): V;
    /**
     * Returns the result entries of the transaction.
     * @returns Returns the node entries that will be created, updated, and deleted by this transaction.
     */
    getResultEntries(): {
        created: TransactionEntry<string, BPTreeNode<K, V>>[];
        updated: TransactionEntry<string, BPTreeNode<K, V>>[];
        deleted: TransactionEntry<string, BPTreeNode<K, V>>[];
    };
    protected _clearCache(): void;
    protected _resetForReload(): void;
    /**
     * Clears all cached nodes.
     * This method is useful for freeing up memory when the tree is no longer needed.
     */
    clear(): void;
    protected _clearInternal(): void;
    protected _binarySearchValues(values: V[], target: V, usePrimary?: boolean, upperBound?: boolean): {
        index: number;
        found: boolean;
    };
}