import { AnyLink, CarMakeable, TransactionMeta, TransactionWrapper, BlockstoreOpts, BlockstoreRuntime, Loadable, FPBlock, BlockFetcher } from "@fireproof/core-types-blockstore";
import { BaseBlockstore, CarTransaction, CarTransactionOpts, CompactStrategyContext, CRDT, CRDTClock, Falsy, SuperThis } from "@fireproof/core-types-base";
import { Logger } from "@adviser/cement";
export declare class CarTransactionImpl implements CarMakeable, CarTransaction {
    #private;
    readonly parent: BaseBlockstore;
    constructor(parent: BaseBlockstore, opts?: CarTransactionOpts);
    get(cid: AnyLink): Promise<FPBlock | Falsy>;
    superGet(cid: AnyLink): Promise<FPBlock | Falsy>;
    put(fb: FPBlock): Promise<void>;
    putSync(fb: FPBlock): void;
    unshift(fb: FPBlock): void;
    entries(): AsyncIterableIterator<FPBlock>;
}
export declare function defaultedBlockstoreRuntime(sthis: SuperThis, opts: BlockstoreOpts, component: string, ctx?: Record<string, unknown>): BlockstoreRuntime;
export declare class BaseBlockstoreImpl implements BlockFetcher {
    readonly transactions: Set<CarTransaction>;
    readonly ebOpts: BlockstoreRuntime;
    readonly sthis: SuperThis;
    readonly crdtParent?: CRDT;
    readonly loader: Loadable;
    ready(): Promise<void>;
    close(): Promise<void>;
    destroy(): Promise<void>;
    compact(): Promise<void>;
    readonly logger: Logger;
    constructor(ebOpts: BlockstoreOpts, crdt?: CRDT);
    get(cid: AnyLink): Promise<FPBlock | Falsy>;
    put(fp: FPBlock): Promise<void>;
    lastTxMeta?: unknown;
    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, _opts?: CarTransactionOpts): Promise<TransactionWrapper<M>>;
    openTransaction(opts?: CarTransactionOpts): CarTransaction;
    commitTransaction<M extends TransactionMeta>(t: CarTransaction, done: M, opts: CarTransactionOpts): Promise<TransactionWrapper<M>>;
    entries(): AsyncIterableIterator<FPBlock>;
}
export declare class EncryptedBlockstore extends BaseBlockstoreImpl {
    ready(): Promise<void>;
    close(): Promise<void>;
    destroy(): Promise<void>;
    compacting: boolean;
    readonly logger: Logger;
    constructor(sthis: SuperThis, ebOpts: BlockstoreOpts, crdt?: CRDT);
    get(cid: AnyLink): Promise<FPBlock | Falsy>;
    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, opts?: {
        noLoader: boolean;
    }): Promise<TransactionWrapper<M>>;
    getFile(car: AnyLink, cid: AnyLink): Promise<Uint8Array>;
    compact(): Promise<void>;
    entries(): AsyncIterableIterator<FPBlock>;
}
export declare class CompactionFetcher implements CompactStrategyContext {
    readonly transactions: Set<CarTransaction>;
    readonly clock?: CRDTClock;
    readonly lastTxMeta: TransactionMeta;
    readonly loader: Loadable;
    readonly logger: Logger;
    readonly blockstore: EncryptedBlockstore;
    readonly loggedBlocks: CarTransaction;
    constructor(blocks: EncryptedBlockstore);
    get(cid: AnyLink): Promise<FPBlock | Falsy>;
}