import { JSONPatch } from './jsonPatch.js';
import { JSONPatchOp } from './types.js';
export type Subscriber<T> = (value: T, meta: SyncableMetadata, hasUnsentChanges: boolean) => void;
export type PatchSubscriber = (value: JSONPatchOp[], rev: string) => void;
export type Unsubscriber = () => void;
export type Sender<T = Record<string, any>> = (changes: JSONPatchOp[]) => Promise<T>;
export type DocRev<T = Record<string, any>> = [T, string];
export type PatchRev = [JSONPatchOp[], string];
export type PatchRevPatch = [JSONPatchOp[], string, JSONPatchOp[]];
export interface SyncableClient<T = Record<string, any>> {
    subscribe: (run: Subscriber<T>) => Unsubscriber;
    change: (patch: JSONPatch | JSONPatchOp[]) => T;
    receive: (patch: JSONPatch | JSONPatchOp[], rev: string, overwriteChanges?: boolean) => T;
    send<T>(sender: Sender<T>): Promise<T | void>;
    get(): T;
    getAll(): [T, SyncableMetadata];
    getMeta(): SyncableMetadata;
    getRev(): string;
    set(value: T, meta: SyncableMetadata): void;
}
export interface SyncableServer<T = Record<string, any>> {
    onPatch: (run: PatchSubscriber) => Unsubscriber;
    getPendingPatch: () => Promise<{
        patch: JSONPatchOp[];
        rev: string;
    }>;
    subscribe: (run: Subscriber<T>) => Unsubscriber;
    change: (patch: JSONPatch | JSONPatchOp[]) => PatchRev;
    receive: (patch: JSONPatch | JSONPatchOp[], rev?: string, ignoreBlackLists?: boolean) => PatchRevPatch;
    changesSince: (rev?: string) => PatchRev;
    get(): T;
    getAll(): [T, SyncableMetadata];
    getMeta(): SyncableMetadata;
    getRev(): string;
    set(value: T, meta: SyncableMetadata): void;
}
export type Combiner = {
    combine: (a: number, b: number) => number;
    apply: (a: number, b: number) => number;
};
export type CombinableOps = {
    [name: string]: Combiner;
};
/**
 * A map of paths that have been changed. The value is zero except for @inc operations which have a number to track the
 * increment value and @bit to track the bitmask operation. 2 @inc operations may be combined and 2 @bit operations may
 * be combined.
 */
export type Changes = Record<string, ChangeOp>;
export type ChangeOp = {
    [op: string]: number;
} | null;
export interface SyncableMetadata {
    rev: string;
    changed?: Changes;
    paths?: {
        [key: string]: string;
    };
}
export type SyncableOptions = {
    whitelist?: Set<string>;
    blacklist?: Set<string>;
    revPad?: number;
};
export interface SyncableServerOptions extends SyncableOptions {
    server: true;
}
export declare function syncable<T>(object: T, meta?: SyncableMetadata, options?: SyncableOptions): SyncableClient<T>;
export declare function syncable<T>(object: T, meta: SyncableMetadata | undefined, options: SyncableServerOptions): SyncableServer<T>;