export { createAuthPlugin } from "./types.js";
export { logger } from "./logger.js";
/**
 * @template {t.YHubConfig} [Conf=t.YHubConfig]
 */
export class YHub<Conf extends t.YHubConfig = {
    events?: {
        docUpdate: (args_0: any, args_1: Y.Doc, args_2: {
            inserts: Y.IdMap<unknown>;
            deletes: Y.IdMap<unknown>;
        }) => undefined;
    } | undefined;
    worker?: {
        events?: {
            docUpdate?: ((doctable: t.DocTable<{
                gc: true;
                nongc: true;
                contentmap: true;
                contentids: true;
            }>) => void) | undefined;
            taskStart?: ((event: {
                room: t.Room;
                timestamp: number;
            }) => void) | undefined;
            taskComplete?: ((event: {
                room: t.Room;
                duration: number;
                error: Error | null;
            }) => void) | undefined;
        } | undefined;
        taskConcurrency: number;
    } | null | undefined;
    server?: {
        maxDocSize?: number | undefined;
        port: number;
        auth: t.AuthPlugin<any>;
    } | null | undefined;
    redis: {
        taskDebounce?: number | undefined;
        minMessageLifetime?: number | undefined;
        cacheTtl?: number | undefined;
        clientOptions?: Omit<import("redis").RedisClientOptions<import("redis").RedisModules, import("redis").RedisFunctions, import("redis").RedisScripts, import("redis").RespVersions, import("redis").TypeMapping, import("@redis/client/dist/lib/client/socket.js").RedisSocketOptions>, "url"> | undefined;
        socket?: import("@redis/client/dist/lib/client/socket.js").RedisSocketOptions | undefined;
        url: string;
        prefix: string;
    };
    postgres: string;
    persistence: t.PersistencePlugin[];
}> {
    /**
     * @param {Conf} conf
     * @param {strm.Stream} str
     * @param {p.Persistence} pers
     */
    constructor(conf: Conf, str: strm.Stream, pers: p.Persistence);
    conf: Conf;
    stream: strm.Stream;
    persistence: p.Persistence;
    /**
     * @type {Conf['server'] extends null ? null : server.YHubServer}
     */
    server: Conf["server"] extends null ? null : server.YHubServer;
    computePool: {
        maxPoolSize: number;
        workers: Array<{
            pool: /*elided*/ any;
            worker: import("worker_threads").Worker;
            isComputing: boolean;
            isDead: boolean;
            taskStart: number;
            taskEnd: number;
            lastUsed: number;
            _cbResolve: ((value: any) => void) | null;
            _cbReject: ((reason: any) => void) | null;
            _logContext: {
                [x: string]: any;
            } | null;
            run(task: ComputeTask, transferList: Array<ArrayBuffer>, logContext: {
                [x: string]: any;
            }, resolve: (value: any) => void, reject: (reason: any) => void): void;
            terminate(): Promise<number>;
        }>;
        queue: {
            task: import("./compute.js").ComputeTask;
            transferList: ArrayBuffer[];
            logContext: {
                [x: string]: any;
            };
            resolve: (value: any) => void;
            reject: (reason: any) => void;
        }[];
        run(task: ComputeTask, transferList: Array<ArrayBuffer>, logContext: {
            [x: string]: any;
        }): Promise<any>;
        mergeUpdates(gc: boolean, updates: Array<Uint8Array<ArrayBuffer>>, logContext?: {
            [x: string]: any;
        }, prune?: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
        computePruneSet(opts: {
            contentmapBin: Uint8Array<ArrayBuffer>;
            from?: number | undefined;
            to?: number | undefined;
            by?: string | undefined;
            contentIds?: Uint8Array<ArrayBuffer> | undefined;
            withCustomAttributions?: {
                k: string;
                v: string;
            }[] | null | undefined;
        }, logContext?: {
            [x: string]: any;
        }): Promise<Uint8Array<ArrayBuffer> | null>;
        computeStateVector(update: Uint8Array<ArrayBuffer>, logContext?: {
            [x: string]: any;
        }): Promise<Uint8Array<ArrayBuffer>>;
        changeset(opts: {
            nongcDoc: Uint8Array<ArrayBuffer>;
            contentmapBin: Uint8Array<ArrayBuffer>;
            from: number | null;
            to: number | null;
            by: string;
            withCustomAttributions: Array<{
                k: string;
                v: string;
            }> | null;
            includeYdoc: boolean;
            includeDelta: boolean;
            includeAttributions: boolean;
        }, logContext?: {
            [x: string]: any;
        }): Promise<Uint8Array<ArrayBuffer>>;
        activity(opts: {
            nongcDoc: Uint8Array<ArrayBuffer>;
            contentmapBin: Uint8Array<ArrayBuffer>;
            from: number;
            to: number;
            by: string;
            contentIds?: Uint8Array<ArrayBuffer> | undefined;
            withCustomAttributions: Array<{
                k: string;
                v: string;
            }> | null;
            includeCustomAttributions: boolean;
            includeDelta: boolean;
            includeYdoc: boolean;
            includeAttributions: boolean;
            limit: number;
            reverse: boolean;
            group: boolean;
            groupMaxGap: number;
            groupMaxDuration: number;
        }, logContext?: {
            [x: string]: any;
        }): Promise<Uint8Array<ArrayBuffer>>;
        patchYdoc(opts: {
            update: Uint8Array<ArrayBuffer>;
            currentDoc: Uint8Array<ArrayBuffer>;
            userid: string;
            customAttributions: Array<{
                k: string;
                v: string;
            }>;
        }, logContext?: {
            [x: string]: any;
        }): Promise<{
            update: Uint8Array<ArrayBuffer>;
            contentmap: Uint8Array<ArrayBuffer>;
        } | null>;
        rollback(opts: {
            nongcDoc: Uint8Array<ArrayBuffer>;
            contentmapBin: Uint8Array<ArrayBuffer>;
            from?: number | undefined;
            to?: number | undefined;
            by?: string | undefined;
            contentIds?: Uint8Array<ArrayBuffer> | undefined;
            withCustomAttributions?: {
                k: string;
                v: string;
            }[] | null | undefined;
            userid: string;
            customAttributions: Array<{
                k: string;
                v: string;
            }>;
        }, logContext?: {
            [x: string]: any;
        }): Promise<{
            update: Uint8Array<ArrayBuffer>;
            contentmap: Uint8Array<ArrayBuffer>;
        }>;
        destroy(): Promise<void>;
    };
    _workerCtx: {
        shouldRun: boolean;
    };
    startWorker(): Promise<void>;
    _ctx: {
        shouldRun: boolean;
    } | undefined;
    stopWorker(): void;
    /**
     * @template {{ gc?: boolean, nongc?: boolean, contentmap?: boolean, references?: boolean, contentids?: boolean, awareness?: boolean }} Include
     * @param {t.Room} room
     * @param {Include} includeContent
     * @param {object} opts
     * @param {boolean} [opts.gcOnMerge] whether to gc when merging updates. (default: true)
     * @param {{ messages: Array<t.Message & { redisClock: string }>, lastClock: string }} [opts.cachedMessages] pre-fetched stream messages, to avoid pulling the redis stream again
     * @return {Promise<t.DocTable<Include>>}
     */
    getDoc<Include extends {
        gc?: boolean;
        nongc?: boolean;
        contentmap?: boolean;
        references?: boolean;
        contentids?: boolean;
        awareness?: boolean;
    }>(room: t.Room, includeContent: Include, { gcOnMerge, cachedMessages: prefetched }?: {
        gcOnMerge?: boolean | undefined;
        cachedMessages?: {
            messages: Array<t.Message & {
                redisClock: string;
            }>;
            lastClock: string;
        } | undefined;
    }): Promise<t.DocTable<Include>>;
    /**
     * Permanently prunes churned history: content that was both inserted and deleted within the
     * filtered range is garbage-collected and removed from the activity history. This is
     * irreversible. The prune is distributed as a directive on the redis stream and baked into
     * persistence the next time the document is compacted.
     *
     * @param {t.Room} room
     * @param {object} filters
     * @param {number} [filters.from]
     * @param {number} [filters.to]
     * @param {string} [filters.by]
     * @param {Uint8Array<ArrayBuffer>} [filters.contentIds]
     * @param {Array<{k: string, v: string}>|null} [filters.withCustomAttributions]
     * @returns {Promise<void>}
     */
    pruneDoc(room: t.Room, filters: {
        from?: number | undefined;
        to?: number | undefined;
        by?: string | undefined;
        contentIds?: Uint8Array<ArrayBuffer> | undefined;
        withCustomAttributions?: {
            k: string;
            v: string;
        }[] | null | undefined;
    }): Promise<void>;
    /**
     * Attribute and persist a document directly to the database, without distributing it via redis.
     *
     * Changes won't be synced to users connected via websocket until they reconnect.
     *
     * @param {t.Room} room
     * @param {Uint8Array<ArrayBuffer>} ydoc
     * @param {{ by?: string }} attributions
     */
    unsafePersistDoc(room: t.Room, ydoc: Uint8Array<ArrayBuffer>, { by }: {
        by?: string;
    }): Promise<void>;
    /**
     * @template R
     * @param {t.Room} room
     * @param {import('./agents.js').AgentTaskOptions} opts
     * @param {(ydoc: Y.Doc, awareness: import('@y/protocols/awareness').Awareness) => Promise<R> | R} handler
     * @returns {Promise<R>}
     */
    agentTask<R>(room: t.Room, opts: import("./agents.js").AgentTaskOptions, handler: (ydoc: Y.Doc, awareness: import("@y/protocols/awareness").Awareness) => Promise<R> | R): Promise<R>;
}
export function createYHub<Conf extends t.YHubConfig>(conf: Conf): Promise<YHub<Conf>>;
import * as t from './types.js';
import * as Y from '@y/y';
import * as strm from './stream.js';
import * as p from './persistence.js';
import * as server from './server.js';
//# sourceMappingURL=index.d.ts.map