import { Log, ISortFunction, LogOptions, Identity, CanAppend, Change, TrimToByteLengthOption, TrimToLengthOption, Change2, EntryType } from "@dao-xyz/peerbit-log";
import { Encoding, EncryptionTemplateMaybeEncrypted } from "@dao-xyz/peerbit-log";
import { Entry } from "@dao-xyz/peerbit-log";
import { BlockStore } from "@dao-xyz/libp2p-direct-block";
import Cache from "@dao-xyz/lazy-level";
import { PublicKeyEncryptionResolver, SignatureWithKey } from "@dao-xyz/peerbit-crypto";
import { EntryWithRefs } from "./entry-with-refs.js";
export declare const logger: import("pino").Logger<import("pino").LoggerOptions | import("pino").DestinationStream>;
export declare class CachedValue {
}
export type AddOperationOptions<T> = {
    skipCanAppendCheck?: boolean;
    identity?: Identity;
    signers?: ((data: Uint8Array) => Promise<SignatureWithKey>)[];
    nexts?: Entry<T>[];
    reciever?: EncryptionTemplateMaybeEncrypted;
    type?: EntryType;
};
export declare class CID {
    hash: string;
    constructor(opts?: {
        hash: string;
    });
}
export declare class CachePath {
    path: string;
    constructor(path: string);
}
export declare class UnsfinishedReplication {
    hashes: string[];
    constructor(opts?: {
        hashes: string[];
    });
}
export declare class HeadsCache {
    heads: string[];
    last?: string;
    counter: bigint;
    constructor(heads: string[], counter: bigint, last?: string);
}
export interface IStoreOptions<T> {
    /**
     * f set to true, will throw an error if the database can't be found locally. (Default: false)
     */
    localOnly?: boolean;
    /**
     * The directory where data will be stored
     */
    directory?: string;
    onWrite?: (store: Store<T>, change: Entry<T>) => void;
    onUpdate?: (change: Change<T>) => void;
    onClose?: (store: Store<T>) => void;
    onDrop?: (store: Store<T>) => void;
    onLoad?: (store: Store<T>) => void;
    onLoadProgress?: (store: Store<T>, entry: Entry<T>) => void;
    onOpen?: (store: Store<any>) => Promise<void>;
    encryption?: PublicKeyEncryptionResolver;
    replicationConcurrency?: number;
    sortFn?: ISortFunction;
    trim?: TrimToByteLengthOption | TrimToLengthOption;
}
export interface IInitializationOptions<T> extends IStoreOptions<T>, IInitializationOptionsDefault<T> {
    resolveCache: (store: Store<any>) => Promise<Cache> | Cache;
    replicator?: (gid: string) => Promise<boolean>;
    replicatorsCacheId?: () => string;
}
interface IInitializationOptionsDefault<T> {
    replicationConcurrency?: number;
    cacheId: string;
}
export declare const DefaultOptions: IInitializationOptionsDefault<any>;
export interface Initiable<T> {
    init?(blockstore: BlockStore, identity: Identity, options: IInitializationOptions<T>): Promise<this>;
}
export declare class Store<T> implements Initiable<T> {
    _storeIndex: number;
    _canAppend?: CanAppend<T>;
    _onUpdate?: (change: Change<T>) => Promise<void> | void;
    _onUpdateOption?: (change: Change<T>) => Promise<void> | void;
    private _options;
    identity: Identity;
    private _headsPathCounter;
    headsPath: string;
    private _lastHeadsPath?;
    private _lastHeadsCount;
    removedHeadsPath: string;
    private _lastRemovedHeadsPath?;
    private _lastRemovedHeadsCount;
    snapshotPath: string;
    initialized: boolean;
    encoding: Encoding<T>;
    private _store;
    private _cache;
    private _oplog;
    private _cacheWriteQueue;
    private _key;
    private _saveFile;
    private _loadFile;
    private _loaded;
    constructor(properties?: {
        storeIndex: number;
    });
    setup(properties: {
        encoding: Encoding<T>;
        canAppend: CanAppend<T>;
        onUpdate: (change: Change<T>) => void;
    }): void;
    init(store: BlockStore, identity: Identity, options: IInitializationOptions<T>): Promise<this>;
    private _updateCachedHeads;
    idle(): Promise<void>;
    getCachedHeads(lastHeadsPath?: string | undefined, lastRemovedHeadsPath?: string | undefined): Promise<string[]>;
    get id(): string;
    get oplog(): Log<T>;
    get key(): string;
    get store(): BlockStore;
    get options(): IInitializationOptions<T>;
    get logOptions(): LogOptions<T>;
    get cache(): Cache;
    setIdentity(identity: Identity): void;
    set canAppend(canAppend: CanAppend<T> | undefined);
    get canAppend(): CanAppend<T> | undefined;
    set onUpdate(onUpdate: (change: Change<T>) => void);
    get closed(): boolean;
    close(): Promise<void>;
    /**
     * Drops a database and removes local data
     */
    drop(): Promise<void>;
    private loadHeads;
    load(opts?: {
        fetchEntryTimeout?: number;
    } & ({
        amount?: number;
    } | {
        heads?: true;
    })): Promise<void>;
    loadLastHeadsPath(): Promise<void>;
    getCachedHeadsCount(headPath?: string): Promise<bigint>;
    private waitForHeads;
    append(data: T, options?: AddOperationOptions<T>): Promise<{
        entry: Entry<T>;
        removed: Entry<T>[];
    }>;
    private removeEntry;
    remove(entry: Entry<T> | Entry<T>[], options?: {
        recursively?: boolean;
    }): Promise<Change<T>>;
    /**
     *
     * @param entries
     * @returns change
     */
    sync(entries: (EntryWithRefs<T> | Entry<T> | string)[], options?: {
        canAppend?: CanAppend<T>;
        onChange?: (change: Change2<any>) => void | Promise<void>;
        timeout?: number;
    }): Promise<void>;
    saveSnapshot(): Promise<string[]>;
    loadFromSnapshot(): Promise<this>;
    _updateIndex(change: Change<T>): Promise<void>;
    _onLoadProgress(entry: Entry<any>): void;
    clone(): Store<T>;
}
export {};