/// <reference types="node" />
import { t } from '../common';
import * as util from './util';
export declare class Db<D extends object = any> implements t.IDb<D> {
    static create<D extends object = any>(args: {
        dir: string;
        dbKey?: string;
        version?: string;
        valueEncoding?: 'utf-8' | 'binary';
    }): Promise<Db<D>>;
    static toValues: typeof util.toValues;
    static toKeyValueList: typeof util.toKeyValueList;
    static toValueList: typeof util.toValueList;
    static ensureTimestamps: typeof util.ensureTimestamps;
    private constructor();
    private readonly _;
    readonly dispose$: import("rxjs").Observable<{}>;
    readonly events$: import("rxjs").Observable<t.DbEvent>;
    readonly watch$: import("rxjs").Observable<t.IDbWatchChange<any>>;
    readonly isDisposed: boolean;
    readonly dir: string;
    readonly key: string;
    readonly localKey: string;
    readonly discoveryKey: string;
    readonly buffer: {
        key: Buffer;
        localKey: Buffer;
        discoveryKey: Buffer;
    };
    readonly watching: string[];
    readonly checkoutVersion: string | undefined;
    dispose(): void;
    replicate(options: {
        live?: boolean;
    }): t.IProtocol;
    isAuthorized(peerKey?: Buffer | string): Promise<boolean>;
    authorize(peerKey: Buffer | string): Promise<void>;
    version(): Promise<string>;
    checkout(version: string): Promise<Db<D>>;
    get<K extends keyof D>(key: K): Promise<t.IDbValue<K, D[K]>>;
    put<K extends keyof D>(key: K, value: D[K]): Promise<t.IDbValue<K, D[K]>>;
    delete<K extends keyof D>(key: K): Promise<t.IDbValue<K, D[K]>>;
    values<T extends object = D>(args?: {
        pattern?: string;
        recursive?: boolean;
        gt?: boolean;
    }): Promise<t.IDbValues<T>>;
    getMany<T extends object = D>(keys: Array<keyof D>): Promise<t.IDbValues<T>>;
    putMany<T extends object = D>(data: t.IDbUpdateObject<T> | t.IDbUpdateList<T>): Promise<t.IDbValues<T>>;
    deleteMany<T extends object = D>(data: Array<keyof T>): Promise<void>;
    private _batch;
    watch<T extends object = D>(...pattern: Array<keyof T>): Promise<void>;
    unwatch<T extends object = D>(...pattern: Array<keyof T>): Promise<void>;
    history<K extends keyof D>(key: K, options?: {
        take?: number;
    }): Promise<t.IDbValue<K, D[K]>[]>;
    stats(options?: {}): Promise<{
        dir: string;
        size: {
            bytes: number;
            toString: (options?: import("@platform/fs/lib/size").IFileSizeStringOptions | undefined) => string;
        };
    }>;
    toString(): string;
    private fireError;
    private next;
    private throwIfDisposed;
    private throwIfNoKey;
}