@dabble/patches 0.2.20 → 0.2.22

package/dist/client/InMemoryStore.d.ts

@@ -7,13 +7,11 @@ import type { PatchesStore, TrackedDoc } from './PatchesStore.js';
  */
 export declare class InMemoryStore implements PatchesStore {
     private docs;
-    /** Signal emitted when pending changes are added (mirrors IndexedDBStore API) */
-    readonly onPendingChanges: import("../event-signal.js").Signal<(docId: string, changes: Change[]) => void>;
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
     getPendingChanges(docId: string): Promise<Change[]>;
     getLastRevs(docId: string): Promise<[number, number]>;
     listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
-    savePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    savePendingChange(docId: string, change: Change): Promise<void>;
     saveCommittedChanges(docId: string, changes: Change[], sentPendingRange?: [number, number]): Promise<void>;
     trackDocs(docIds: string[]): Promise<void>;
     untrackDocs(docIds: string[]): Promise<void>;

package/dist/client/InMemoryStore.js

@@ -1,4 +1,3 @@
-import { signal } from '../event-signal.js';
 import { transformPatch } from '../json-patch/transformPatch.js';
 import { applyChanges } from '../utils.js';
 /**
@@ -9,8 +8,6 @@ import { applyChanges } from '../utils.js';
 export class InMemoryStore {
     constructor() {
         this.docs = new Map();
-        /** Signal emitted when pending changes are added (mirrors IndexedDBStore API) */
-        this.onPendingChanges = signal();
     }
     // ─── Reconstruction ────────────────────────────────────────────────────
     async getDoc(docId) {
@@ -55,12 +52,11 @@ export class InMemoryStore {
         }));
     }
     // ─── Writes ────────────────────────────────────────────────────────────
-    async savePendingChanges(docId, changes) {
+    async savePendingChange(docId, change) {
         const buf = this.docs.get(docId) ?? { committed: [], pending: [] };
         if (!this.docs.has(docId))
             this.docs.set(docId, buf);
-        buf.pending.push(...changes);
-        this.onPendingChanges.emit(docId, changes);
+        buf.pending.push(change);
     }
     async saveCommittedChanges(docId, changes, sentPendingRange) {
         const buf = this.docs.get(docId) ?? { committed: [], pending: [] };

package/dist/client/IndexedDBStore.d.ts

@@ -16,8 +16,6 @@ export declare class IndexedDBStore implements PatchesStore {
     private db;
     private dbName?;
     private dbPromise;
-    /** Subscribe to be notified after local state changes are saved to the database. */
-    readonly onPendingChanges: import("../event-signal.js").Signal<(docId: string, changes: Change[]) => void>;
     constructor(dbName?: string);
     private initDB;
     private getDB;
@@ -54,7 +52,7 @@ export declare class IndexedDBStore implements PatchesStore {
      * Append an array of local changes to the pending queue.
      * Called *before* you attempt to send them to the server.
      */
-    savePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    savePendingChange(docId: string, change: Change): Promise<void>;
     /** Read back all pending changes for this docId (in order). */
     getPendingChanges(docId: string): Promise<Change[]>;
     /**

package/dist/client/IndexedDBStore.js

@@ -1,4 +1,3 @@
-import { signal } from '../event-signal.js';
 import { transformPatch } from '../json-patch/transformPatch.js';
 import { applyChanges, deferred } from '../utils.js';
 const DB_VERSION = 1;
@@ -18,8 +17,6 @@ const SNAPSHOT_INTERVAL = 200;
 export class IndexedDBStore {
     constructor(dbName) {
         this.db = null;
-        /** Subscribe to be notified after local state changes are saved to the database. */
-        this.onPendingChanges = signal();
         this.dbName = dbName;
         this.dbPromise = deferred();
         if (this.dbName) {
@@ -169,7 +166,7 @@ export class IndexedDBStore {
      * Append an array of local changes to the pending queue.
      * Called *before* you attempt to send them to the server.
      */
-    async savePendingChanges(docId, changes) {
+    async savePendingChange(docId, change) {
         const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
         let docMeta = await docsStore.get(docId);
         if (!docMeta) {
@@ -181,8 +178,7 @@ export class IndexedDBStore {
             await docsStore.put(docMeta);
             console.warn(`Revived document ${docId} by saving pending changes.`);
         }
-        await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
-        this.onPendingChanges.emit(docId, changes);
+        await pendingChanges.put({ ...change, docId });
         await tx.complete();
     }
     /** Read back all pending changes for this docId (in order). */

package/dist/client/Patches.js

@@ -207,12 +207,9 @@ export class Patches {
      * @returns An Unsubscriber function to remove the listener.
      */
     _setupLocalDocListener(docId, doc) {
-        return doc.onChange(async () => {
-            const changes = doc.getUpdatesForServer();
-            if (!changes.length)
-                return;
+        return doc.onChange(async (change) => {
             try {
-                await this.store.savePendingChanges(docId, changes);
+                await this.store.savePendingChange(docId, change);
                 // Note: When used with PatchesSync, it will handle flushing the changes
             }
             catch (err) {

package/dist/client/PatchesHistoryClient.d.ts

@@ -1,5 +1,5 @@
 import type { PatchesAPI } from '../net/protocol/types.js';
-import type { Change, ListVersionsOptions, VersionMetadata } from '../types.js';
+import type { Change, EditableVersionMetadata, ListVersionsOptions, VersionMetadata } from '../types.js';
 /**
  * Client-side history/scrubbing interface for a document.
  * Read-only: allows listing versions, loading states/changes, and scrubbing.
@@ -23,9 +23,9 @@ export declare class PatchesHistoryClient<T = any> {
     /** List version metadata for this document (with options) */
     listVersions(options?: ListVersionsOptions): Promise<VersionMetadata[]>;
     /** Create a new named version snapshot of the document's current state. */
-    createVersion(name: string): Promise<string>;
+    createVersion(metadata: EditableVersionMetadata): Promise<string>;
     /** Update the name of a specific version. */
-    updateVersion(versionId: string, updates: Pick<VersionMetadata, 'name'>): Promise<void>;
+    updateVersion(versionId: string, metadata: EditableVersionMetadata): Promise<void>;
     /** Load the state for a specific version */
     getStateAtVersion(versionId: string): Promise<any>;
     /** Load the changes for a specific version */

package/dist/client/PatchesHistoryClient.js

@@ -62,14 +62,14 @@ export class PatchesHistoryClient {
         return this._versions;
     }
     /** Create a new named version snapshot of the document's current state. */
-    async createVersion(name) {
-        const versionId = await this.api.createVersion(this.id, name);
+    async createVersion(metadata) {
+        const versionId = await this.api.createVersion(this.id, metadata);
         await this.listVersions(); // Refresh the list of versions
         return versionId;
     }
     /** Update the name of a specific version. */
-    async updateVersion(versionId, updates) {
-        await this.api.updateVersion(this.id, versionId, updates);
+    async updateVersion(versionId, metadata) {
+        await this.api.updateVersion(this.id, versionId, metadata);
         await this.listVersions(); // Refresh the list of versions
     }
     /** Load the state for a specific version */

package/dist/client/PatchesStore.d.ts

@@ -27,7 +27,7 @@ export interface PatchesStore {
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
     getPendingChanges(docId: string): Promise<Change[]>;
     getLastRevs(docId: string): Promise<[committedRev: number, pendingRev: number]>;
-    savePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    savePendingChange(docId: string, change: Change): Promise<void>;
     saveCommittedChanges(docId: string, changes: Change[], sentPendingRange?: [number, number]): Promise<void>;
     /** Permanently delete document (writes tombstone so server delete happens later). */
     deleteDoc(docId: string): Promise<void>;

package/dist/net/protocol/JSONRPCServer.d.ts

@@ -1,7 +1,8 @@
-import { type Unsubscriber } from '../../event-signal.js';
-import type { Notification, Request, ServerTransport } from './types.js';
-export type ConnectionSignalSubscriber = (connectionId: string, ...args: any[]) => any;
-export type MessageHandler<P = any, R = any> = (connectionId: string, params: P) => Promise<R> | R;
+import { type Signal, type Unsubscriber } from '../../event-signal.js';
+import type { AuthContext } from '../websocket/AuthorizationProvider.js';
+import type { Notification } from './types.js';
+export type ConnectionSignalSubscriber = (params: any, clientId?: string) => any;
+export type MessageHandler<P = any, R = any> = (params: P, ctx?: AuthContext) => Promise<R> | R;
 /**
  * Lightweight JSON-RPC 2.0 server adapter for {@link PatchesServer}.
  *
@@ -19,12 +20,12 @@ export type MessageHandler<P = any, R = any> = (connectionId: string, params: P)
  *     to the host application.
  */
 export declare class JSONRPCServer {
-    protected transport: ServerTransport;
     /** Map of fully-qualified JSON-RPC method → handler function */
     private readonly handlers;
     /** Allow external callers to emit server-initiated notifications. */
     private readonly notificationSignals;
-    constructor(transport: ServerTransport);
+    /** Allow external callers to emit server-initiated notifications. */
+    readonly onNotify: Signal<(msg: Notification, exceptConnectionId?: string) => void>;
     /**
      * Registers a JSON-RPC method.
      *
@@ -45,25 +46,20 @@ export declare class JSONRPCServer {
      * Sends a JSON-RPC notification (no `id`, therefore no response expected) to
      * the connected client.
      */
-    notify(connectionIds: string[], method: string, params?: any): void;
-    /**
-     * Handles incoming messages from the client.
-     * @param connectionId - The WebSocket transport object.
-     * @param raw - The raw message string.
-     */
-    protected _onMessage(connectionId: string, raw: string): Promise<void>;
-    /**
-     * Handles incoming JSON-RPC requests from the client.
-     * @param connectionId - The WebSocket transport object.
-     * @param req - The JSON-RPC request object.
-     */
-    protected _handleRequest(connectionId: string, req: Request): Promise<void>;
+    notify(method: string, params?: any, exceptConnectionId?: string): Promise<void>;
     /**
-     * Handles incoming JSON-RPC notifications from the client.
-     * @param connectionId - The WebSocket transport object.
-     * @param note - The JSON-RPC notification object.
+     * Synchronously processes a raw JSON-RPC frame from a client and returns the
+     * encoded response frame – or `undefined` when the message is a notification
+     * (no response expected).
+     *
+     * This helper makes the RPC engine usable for stateless transports such as
+     * HTTP: the host simply passes the request body and sends back the returned
+     * string (if any).
+     *
+     * WebSocket and other bidirectional transports delegate to the same logic
+     * internally; the returned string is forwarded over the socket.
      */
-    protected _handleNotification(connectionId: string, note: Notification): Promise<void>;
+    processMessage(raw: string, ctx?: AuthContext): Promise<string | undefined>;
     /**
      * Maps JSON-RPC method names to {@link PatchesServer} calls.
      * @param connectionId - The WebSocket transport object.
@@ -71,9 +67,5 @@ export declare class JSONRPCServer {
      * @param params - The JSON-RPC parameters.
      * @returns The result of the {@link PatchesServer} call.
      */
-    protected _dispatch(connectionId: string, method: string, params: any): Promise<any>;
-    /**
-     * Sends a JSON-RPC error object back to the client.
-     */
-    private _sendError;
+    protected _dispatch(method: string, params: any, ctx?: AuthContext): Promise<any>;
 }

package/dist/net/protocol/JSONRPCServer.js

@@ -1,5 +1,4 @@
 import { signal } from '../../event-signal.js';
-import { PatchesServer } from '../../server/PatchesServer.js';
 /**
  * Lightweight JSON-RPC 2.0 server adapter for {@link PatchesServer}.
  *
@@ -17,13 +16,13 @@ import { PatchesServer } from '../../server/PatchesServer.js';
  *     to the host application.
  */
 export class JSONRPCServer {
-    constructor(transport) {
-        this.transport = transport;
+    constructor() {
         /** Map of fully-qualified JSON-RPC method → handler function */
         this.handlers = new Map();
         /** Allow external callers to emit server-initiated notifications. */
         this.notificationSignals = new Map();
-        transport.onMessage(this._onMessage.bind(this));
+        /** Allow external callers to emit server-initiated notifications. */
+        this.onNotify = signal();
     }
     // -------------------------------------------------------------------------
     // Registration API
@@ -63,63 +62,56 @@ export class JSONRPCServer {
      * Sends a JSON-RPC notification (no `id`, therefore no response expected) to
      * the connected client.
      */
-    notify(connectionIds, method, params) {
+    async notify(method, params, exceptConnectionId) {
         const msg = { jsonrpc: '2.0', method, params };
-        const msgStr = JSON.stringify(msg);
-        connectionIds.forEach(id => this.transport.send(id, msgStr));
+        this.onNotify.emit(msg, exceptConnectionId);
     }
     /**
-     * Handles incoming messages from the client.
-     * @param connectionId - The WebSocket transport object.
-     * @param raw - The raw message string.
+     * Synchronously processes a raw JSON-RPC frame from a client and returns the
+     * encoded response frame – or `undefined` when the message is a notification
+     * (no response expected).
+     *
+     * This helper makes the RPC engine usable for stateless transports such as
+     * HTTP: the host simply passes the request body and sends back the returned
+     * string (if any).
+     *
+     * WebSocket and other bidirectional transports delegate to the same logic
+     * internally; the returned string is forwarded over the socket.
      */
-    async _onMessage(connectionId, raw) {
+    async processMessage(raw, ctx) {
         let message;
+        // --- Parse & basic validation ------------------------------------------------
         try {
             message = JSON.parse(raw);
         }
         catch (err) {
-            this._sendError(connectionId, null, -32700, 'Parse error', err);
-            return;
+            return rpcError(-32700, 'Parse error', err);
+        }
+        // Ensure it looks like a JSON-RPC call (must have a method field)
+        if (!message || typeof message !== 'object' || !('method' in message)) {
+            const invalidId = message?.id ?? null;
+            return rpcError(-32600, 'Invalid Request', invalidId);
         }
-        if (message && typeof message === 'object' && 'method' in message) {
-            // Notification or request either way--delegate.
-            if ('id' in message && message.id !== undefined) {
-                await this._handleRequest(connectionId, message);
+        // --- Distinguish request vs. notification -----------------------------------
+        if ('id' in message && message.id !== undefined) {
+            // -> Request ----------------------------------------------------------------
+            try {
+                const result = await this._dispatch(message.method, message.params, ctx);
+                const response = { jsonrpc: '2.0', id: message.id, result };
+                return JSON.stringify(response);
             }
-            else {
-                await this._handleNotification(connectionId, message);
+            catch (err) {
+                return rpcError(err?.code ?? -32000, err?.message ?? 'Server error', err?.stack);
             }
         }
         else {
-            // Client sent something we do not understand.
-            this._sendError(connectionId, message?.id ?? null, -32600, 'Invalid Request');
-        }
-    }
-    /**
-     * Handles incoming JSON-RPC requests from the client.
-     * @param connectionId - The WebSocket transport object.
-     * @param req - The JSON-RPC request object.
-     */
-    async _handleRequest(connectionId, req) {
-        try {
-            const result = await this._dispatch(connectionId, req.method, req.params);
-            const response = { jsonrpc: '2.0', id: req.id, result };
-            this.transport.send(connectionId, JSON.stringify(response));
-        }
-        catch (err) {
-            this._sendError(connectionId, req.id, -32000, err?.message ?? 'Server error', err?.stack);
-        }
-    }
-    /**
-     * Handles incoming JSON-RPC notifications from the client.
-     * @param connectionId - The WebSocket transport object.
-     * @param note - The JSON-RPC notification object.
-     */
-    async _handleNotification(connectionId, note) {
-        const thisSignal = this.notificationSignals.get(note.method);
-        if (thisSignal) {
-            thisSignal.emit(connectionId, note.params);
+            // -> Notification -----------------------------------------------------------
+            // Forward the notification to any listeners and return nothing.
+            const thisSignal = this.notificationSignals.get(message.method);
+            if (thisSignal) {
+                thisSignal.emit(message.params, ctx?.clientId);
+            }
+            return undefined;
         }
     }
     /**
@@ -129,7 +121,7 @@ export class JSONRPCServer {
      * @param params - The JSON-RPC parameters.
      * @returns The result of the {@link PatchesServer} call.
      */
-    async _dispatch(connectionId, method, params) {
+    async _dispatch(method, params, ctx) {
         const handler = this.handlers.get(method);
         if (!handler) {
             throw new Error(`Unknown method '${method}'.`);
@@ -137,17 +129,9 @@ export class JSONRPCServer {
         if (!params || typeof params !== 'object' || Array.isArray(params)) {
             throw new Error(`Invalid parameters for method '${method}'.`);
         }
-        return handler(connectionId, params);
-    }
-    /**
-     * Sends a JSON-RPC error object back to the client.
-     */
-    _sendError(connectionId, id, code, message, data) {
-        const errorObj = {
-            jsonrpc: '2.0',
-            id: id,
-            error: { code, message, data },
-        }; // type cast because TS cannot narrow when error present
-        this.transport.send(connectionId, JSON.stringify(errorObj));
+        return handler(params, ctx);
     }
 }
+function rpcError(code, message, data) {
+    return JSON.stringify({ jsonrpc: '2.0', id: null, error: { code, message, data } });
+}

package/dist/net/protocol/types.d.ts

@@ -39,6 +39,12 @@ export interface ServerTransport {
     send(toConnectionId: string, raw: string): void | Promise<void>;
     /** Subscribe to incoming raw frames from any client */
     onMessage(cb: (fromConnectionId: string, raw: string) => void): Unsubscriber;
+    /** Lists all subscriptions for a document. */
+    listSubscriptions(docId: string): Promise<string[]>;
+    /** Adds a subscription for a client to one or more documents. */
+    addSubscription(clientId: string, docIds: string[]): Promise<string[]>;
+    /** Removes a subscription for a client from one or more documents. */
+    removeSubscription(clientId: string, docIds: string[]): Promise<string[]>;
 }
 /**
  * Represents a JSON-RPC 2.0 request object.

package/dist/net/websocket/AuthorizationProvider.d.ts

@@ -5,13 +5,22 @@
  * "write" – mutating operations (commitChanges, deleteDoc, …)
  */
 export type Access = 'read' | 'write';
+/**
+ * Context object for authorization providers.
+ * @property {string} clientId - The ID of the client making the request.
+ * @property {any} [data] - Additional data associated with the request.
+ */
+export interface AuthContext {
+    clientId?: string;
+    [k: string]: any;
+}
 /**
  * Allows the host application to decide whether a given connection can perform
  * a certain action on a document.  Implementations are entirely application-
  * specific – they may look at a JWT decoded during the WebSocket handshake,
  * consult an ACL service, inspect the actual RPC method, etc.
  */
-export interface AuthorizationProvider {
+export interface AuthorizationProvider<T extends AuthContext = AuthContext> {
     /**
      * General-purpose hook executed for every JSON-RPC call that targets a
      * document. Implementations are free to look only at the first three
@@ -22,13 +31,13 @@ export interface AuthorizationProvider {
      * Returning `true` (or a resolved promise with `true`) permits the action.
      * Returning `false` or throwing will cause the RPC to fail with an error.
      *
-     * @param connectionId  WebSocket connection ID of the caller
+     * @param ctx           Context object containing client ID and additional data
      * @param docId         Logical document to be accessed (branch IDs count)
      * @param kind          High-level access category – `'read' | 'write'`
      * @param method        JSON-RPC method name (e.g. `getDoc`, `branch.merge`)
      * @param params        The exact parameter object supplied by the client
      */
-    canAccess(connectionId: string, docId: string, kind: Access, method: string, params?: Record<string, any>): boolean | Promise<boolean>;
+    canAccess(ctx: T | undefined, docId: string, kind: Access, method: string, params?: Record<string, any>): boolean | Promise<boolean>;
 }
 /**
  * A permissive provider that authorises every action.  Used as the default so

package/dist/net/websocket/RPCServer.d.ts

@@ -0,0 +1,120 @@
+import type { PatchesBranchManager } from '../../server/PatchesBranchManager.js';
+import type { PatchesHistoryManager } from '../../server/PatchesHistoryManager.js';
+import type { PatchesServer } from '../../server/PatchesServer.js';
+import type { Change, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions } from '../../types.js';
+import { JSONRPCServer } from '../protocol/JSONRPCServer.js';
+import type { ServerTransport } from '../protocol/types.js';
+import type { AuthContext, AuthorizationProvider } from './AuthorizationProvider.js';
+/**
+ * High-level client for the Patches real-time collaboration service.
+ * This class provides document subscription, patch notification handling,
+ * versioning, and other OT-specific functionality over a JSON RPC interface.
+ */
+export interface RPCServerOptions {
+    transport: ServerTransport;
+    patches: PatchesServer;
+    history?: PatchesHistoryManager;
+    branches?: PatchesBranchManager;
+    auth?: AuthorizationProvider;
+}
+export declare class RPCServer {
+    rpc: JSONRPCServer;
+    auth: AuthorizationProvider;
+    protected patches: PatchesServer;
+    protected history?: PatchesHistoryManager;
+    protected branches?: PatchesBranchManager;
+    /**
+     * Creates a new Patches WebSocket client instance.
+     * @param patches - The patches server instance to handle document operations
+     * @param history - (Optional) History manager instance to handle versioning operations
+     * @param branches - (Optional) Branch manager instance to handle branching operations
+     * @param auth - (Optional) Authorization provider implementation. Defaults to a permissive provider.
+     */
+    constructor({ patches, history, branches, auth }: RPCServerOptions);
+    /**
+     * Gets the latest state (content and revision) of a document.
+     * @param connectionId - The ID of the connection making the request
+     * @param params - The document parameters
+     * @param params.docId - The ID of the document
+     * @param params.atRev - Optional revision number to get document state at
+     */
+    getDoc(params: {
+        docId: string;
+        atRev?: number;
+    }, ctx?: AuthContext): Promise<import("../../types.js").PatchesSnapshot<any>>;
+    /**
+     * Gets changes that occurred for a document after a specific revision number.
+     * @param connectionId - The ID of the connection making the request
+     * @param params - The change request parameters
+     * @param params.docId - The ID of the document
+     * @param params.rev - The revision number after which to fetch changes
+     */
+    getChangesSince(params: {
+        docId: string;
+        rev: number;
+    }, ctx?: AuthContext): Promise<Change[]>;
+    /**
+     * Applies a set of client-generated changes to a document on the server.
+     * @param connectionId - The ID of the connection making the request
+     * @param params - The change parameters
+     * @param params.docId - The ID of the document
+     * @param params.changes - An array of changes to apply
+     */
+    commitChanges(params: {
+        docId: string;
+        changes: Change[];
+    }, ctx?: AuthContext): Promise<Change[]>;
+    /**
+     * Deletes a document on the server.
+     * @param connectionId - The ID of the connection making the request
+     * @param params - The deletion parameters
+     * @param params.docId - The ID of the document to delete
+     */
+    deleteDoc(params: {
+        docId: string;
+    }, ctx?: AuthContext): Promise<void>;
+    listVersions(params: {
+        docId: string;
+        options?: ListVersionsOptions;
+    }, ctx?: AuthContext): Promise<import("../../types.js").VersionMetadata[]>;
+    createVersion(params: {
+        docId: string;
+        metadata: EditableVersionMetadata;
+    }, ctx?: AuthContext): Promise<string>;
+    updateVersion(params: {
+        docId: string;
+        versionId: string;
+        metadata: EditableVersionMetadata;
+    }, ctx?: AuthContext): Promise<void>;
+    getStateAtVersion(params: {
+        docId: string;
+        versionId: string;
+    }, ctx?: AuthContext): Promise<any>;
+    getChangesForVersion(params: {
+        docId: string;
+        versionId: string;
+    }, ctx?: AuthContext): Promise<Change[]>;
+    listServerChanges(params: {
+        docId: string;
+        options?: ListChangesOptions;
+    }, ctx?: AuthContext): Promise<Change[]>;
+    listBranches(params: {
+        docId: string;
+    }, ctx?: AuthContext): Promise<import("../../types.js").Branch[]>;
+    createBranch(params: {
+        docId: string;
+        rev: number;
+        metadata?: EditableVersionMetadata;
+    }, ctx?: AuthContext): Promise<string>;
+    closeBranch(params: {
+        branchId: string;
+    }, ctx?: AuthContext): Promise<void>;
+    mergeBranch(params: {
+        branchId: string;
+    }, ctx?: AuthContext): Promise<Change[]>;
+    protected assertAccess(ctx: AuthContext | undefined, docId: string, kind: 'read' | 'write', method: string, params?: Record<string, any>): Promise<void>;
+    protected assertRead(ctx: AuthContext | undefined, docId: string, method: string, params?: Record<string, any>): Promise<void>;
+    protected assertWrite(ctx: AuthContext | undefined, docId: string, method: string, params?: Record<string, any>): Promise<void>;
+    protected assertHistoryEnabled(): void;
+    protected assertBranchingEnabled(): void;
+}