@hocuspocus/provider 2.5.0 → 2.6.0

package/dist/packages/provider/src/HocuspocusProviderWebsocket.d.ts

@@ -4,6 +4,9 @@ import { Event } from 'ws';
 import EventEmitter from './EventEmitter.js';
 import { HocuspocusProvider } from './HocuspocusProvider.js';
 import { WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.js';
+export type HocusPocusWebSocket = WebSocket & {
+    identifier: string;
+};
 export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
 export interface CompleteHocuspocusProviderWebsocketConfiguration {
     /**
@@ -79,10 +82,14 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     private messageQueue;
     configuration: CompleteHocuspocusProviderWebsocketConfiguration;
     subscribedToBroadcastChannel: boolean;
-    webSocket: WebSocket | null;
+    webSocket: HocusPocusWebSocket | null;
+    webSocketHandlers: {
+        [key: string]: any;
+    };
     shouldConnect: boolean;
     status: WebSocketStatus;
     lastMessageReceived: number;
+    identifier: number;
     mux: mutex.mutex;
     intervals: any;
     connectionAttempt: {
@@ -100,6 +107,8 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     boundConnect: () => Promise<unknown>;
     cancelWebsocketRetry?: () => void;
     connect(): Promise<unknown>;
+    attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function): void;
+    cleanupWebSocket(): void;
     createWebSocketConnection(): Promise<unknown>;
     onMessage(event: MessageEvent): void;
     resolveConnectionAttempt(): void;
@@ -107,7 +116,6 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     rejectConnectionAttempt(): void;
     closeTries: number;
     checkConnection(): void;
-    registerEventListeners(): void;
     get serverUrl(): string;
     get url(): string;
     disconnect(): void;

package/dist/packages/provider/src/TiptapCollabProvider.d.ts

@@ -1,6 +1,7 @@
 import type { AbstractType, YArrayEvent } from 'yjs';
 import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
+import type { THistoryVersion } from './types';
 export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>>);
 export interface AdditionalTiptapCollabProviderConfiguration {
     /**
@@ -9,19 +10,29 @@ export interface AdditionalTiptapCollabProviderConfiguration {
     appId?: string;
     websocketProvider?: TiptapCollabProviderWebsocket;
 }
-export type AuditHistoryVersion = {
-    name?: string;
-    version: number;
-    date: number;
-};
 export declare class TiptapCollabProvider extends HocuspocusProvider {
     tiptapCollabConfigurationPrefix: string;
     constructor(configuration: TiptapCollabProviderConfiguration);
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
     createVersion(name?: string): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
     revertToVersion(targetVersion: number): void;
-    getVersions(): AuditHistoryVersion[];
-    watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]): void;
-    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     *
+     * The server will reply with a stateless message (THistoryVersionPreviewEvent)
+     */
+    previewVersion(targetVersion: number): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
+    getVersions(): THistoryVersion[];
+    watchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['observe']>[0]): void;
+    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['unobserve']>[0]): void;
     isAutoVersioning(): boolean;
     enableAutoVersioning(): 1;
     disableAutoVersioning(): 0;

package/dist/packages/provider/src/types.d.ts

@@ -84,3 +84,48 @@ export type StatesArray = {
     clientId: number;
     [key: string | number]: any;
 }[];
+export type THistoryVersion = {
+    name?: string;
+    version: number;
+    date: number;
+};
+export type THistoryConfiguration = {
+    autoVersioning: boolean;
+    currentVersion: number;
+    stateCaptured: number;
+};
+export type THistoryAction = THistoryDocumentRevertAction | THistoryVersionCreateAction | THistoryVersionPreviewAction;
+export type THistoryDocumentRevertAction = {
+    action: 'document.revert';
+    /**
+     * if changes havent been persisted to a version yet, we'll create one with the specified name,
+     * expect when `false` is passed.
+     */
+    currentVersionName?: string | false;
+    /**
+     * Name of the version that is created after the revert. Pass `false` to avoid generating a new version.
+     */
+    newVersionName?: string | false;
+};
+export type THistoryVersionCreateAction = {
+    action: 'version.create';
+    name?: string;
+};
+export type THistoryVersionPreviewAction = {
+    action: 'version.preview';
+    version: number;
+};
+export type THistoryEvent = THistoryVersionPreviewEvent | THistoryVersionCreatedEvent | THistoryDocumentRevertedEvent;
+export type THistoryVersionCreatedEvent = {
+    event: 'version.created';
+    version: number;
+};
+export type THistoryVersionPreviewEvent = {
+    event: 'version.preview';
+    version: number;
+    ydoc: string;
+};
+export type THistoryDocumentRevertedEvent = {
+    event: 'document.reverted';
+    version: number;
+};

package/dist/packages/server/src/types.d.ts

@@ -39,7 +39,7 @@ export interface Extension {
     connected?(data: connectedPayload): Promise<any>;
     onAuthenticate?(data: onAuthenticatePayload): Promise<any>;
     onLoadDocument?(data: onLoadDocumentPayload): Promise<any>;
-    afterLoadDocument?(data: onLoadDocumentPayload): Promise<any>;
+    afterLoadDocument?(data: afterLoadDocumentPayload): Promise<any>;
     beforeHandleMessage?(data: beforeHandleMessagePayload): Promise<any>;
     beforeBroadcastStateless?(data: beforeBroadcastStatelessPayload): Promise<any>;
     onStateless?(payload: onStatelessPayload): Promise<any>;
@@ -49,7 +49,7 @@ export interface Extension {
     onAwarenessUpdate?(data: onAwarenessUpdatePayload): Promise<any>;
     onRequest?(data: onRequestPayload): Promise<any>;
     onDisconnect?(data: onDisconnectPayload): Promise<any>;
-    afterUnloadDocument?(data: onLoadDocumentPayload): Promise<any>;
+    afterUnloadDocument?(data: afterUnloadDocumentPayload): Promise<any>;
     onDestroy?(data: onDestroyPayload): Promise<any>;
 }
 export type HookName = 'onConfigure' | 'onListen' | 'onUpgrade' | 'onConnect' | 'connected' | 'onAuthenticate' | 'onLoadDocument' | 'afterLoadDocument' | 'beforeHandleMessage' | 'beforeBroadcastStateless' | 'onStateless' | 'onChange' | 'onStoreDocument' | 'afterStoreDocument' | 'onAwarenessUpdate' | 'onRequest' | 'onDisconnect' | 'afterUnloadDocument' | 'onDestroy';
@@ -61,7 +61,7 @@ export type HookPayloadByName = {
     connected: connectedPayload;
     onAuthenticate: onAuthenticatePayload;
     onLoadDocument: onLoadDocumentPayload;
-    afterLoadDocument: onLoadDocumentPayload;
+    afterLoadDocument: afterLoadDocumentPayload;
     beforeHandleMessage: beforeHandleMessagePayload;
     beforeBroadcastStateless: beforeBroadcastStatelessPayload;
     onStateless: onStatelessPayload;
@@ -140,6 +140,7 @@ export interface onAuthenticatePayload {
     connection: ConnectionConfiguration;
 }
 export interface onConnectPayload {
+    context: any;
     documentName: string;
     instance: Hocuspocus;
     request: IncomingMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/common": "^2.5.0",
+    "@hocuspocus/common": "^2.6.0",
     "@lifeomic/attempt": "^3.0.2",
     "lib0": "^0.2.47",
     "ws": "^7.5.9"

package/src/HocuspocusProvider.ts

@@ -367,6 +367,10 @@ export class HocuspocusProvider extends EventEmitter {
 
   // not needed, but provides backward compatibility with e.g. lexicla/yjs
   async connect() {
+    if (this.configuration.broadcast) {
+      this.subscribeToBroadcastChannel()
+    }
+
     return this.configuration.websocketProvider.connect()
   }
 

package/src/HocuspocusProviderWebsocket.ts

@@ -15,6 +15,8 @@ import {
   onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters,
 } from './types.js'
 
+export type HocusPocusWebSocket = WebSocket & { identifier: string };
+
 export type HocuspocusProviderWebsocketConfiguration =
   Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>>
   & Partial<CompleteHocuspocusProviderWebsocketConfiguration>
@@ -136,7 +138,9 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   subscribedToBroadcastChannel = false
 
-  webSocket: WebSocket | null = null
+  webSocket: HocusPocusWebSocket | null = null
+
+  webSocketHandlers: { [key: string]: any } = {}
 
   shouldConnect = true
 
@@ -144,6 +148,8 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   lastMessageReceived = 0
 
+  identifier = 0
+
   mux = mutex.createMutex()
 
   intervals: any = {
@@ -152,15 +158,17 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
   }
 
   connectionAttempt: {
-    resolve: (value?: any) => void
-    reject: (reason?: any) => void
+    resolve: (value?: any) => void;
+    reject: (reason?: any) => void;
   } | null = null
 
   constructor(configuration: HocuspocusProviderWebsocketConfiguration) {
     super()
     this.setConfiguration(configuration)
 
-    this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill ? configuration.WebSocketPolyfill : WebSocket
+    this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill
+      ? configuration.WebSocketPolyfill
+      : WebSocket
 
     this.on('open', this.configuration.onOpen)
     this.on('open', this.onOpen.bind(this))
@@ -178,8 +186,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     this.on('close', this.onClose.bind(this))
     this.on('message', this.onMessage.bind(this))
 
-    this.registerEventListeners()
-
     this.intervals.connectionChecker = setInterval(
       this.checkConnection.bind(this),
       this.configuration.messageReconnectTimeout / 10,
@@ -224,10 +230,11 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   detach(provider: HocuspocusProvider) {
     // tell the server to remove the listener
-
   }
 
-  public setConfiguration(configuration: Partial<HocuspocusProviderWebsocketConfiguration> = {}): void {
+  public setConfiguration(
+    configuration: Partial<HocuspocusProviderWebsocketConfiguration> = {},
+  ): void {
     this.configuration = { ...this.configuration, ...configuration }
   }
 
@@ -289,24 +296,60 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     return retryPromise
   }
 
+  attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function) {
+    const { identifier } = ws
+    const onMessageHandler = (payload: any) => this.emit('message', payload)
+    const onCloseHandler = (payload: any) => this.emit('close', { event: payload })
+    const onOpenHandler = (payload: any) => this.emit('open', payload)
+    const onErrorHandler = (err: any) => {
+      reject(err)
+    }
+
+    this.webSocketHandlers[identifier] = {
+      message: onMessageHandler,
+      close: onCloseHandler,
+      open: onOpenHandler,
+      error: onErrorHandler,
+    }
+
+    const handlers = this.webSocketHandlers[ws.identifier]
+
+    Object.keys(handlers).forEach(name => {
+      ws.addEventListener(name, handlers[name])
+    })
+  }
+
+  cleanupWebSocket() {
+    if (!this.webSocket) {
+      return
+    }
+    const { identifier } = this.webSocket
+    const handlers = this.webSocketHandlers[identifier]
+
+    Object.keys(handlers).forEach(name => {
+      this.webSocket?.removeEventListener(name, handlers[name])
+      delete this.webSocketHandlers[identifier]
+    })
+    this.webSocket.close()
+    this.webSocket = null
+  }
+
   createWebSocketConnection() {
     return new Promise((resolve, reject) => {
       if (this.webSocket) {
         this.messageQueue = []
-        this.webSocket.close()
-        this.webSocket = null
+        this.cleanupWebSocket()
       }
       this.lastMessageReceived = 0
+      this.identifier += 1
 
       // Init the WebSocket connection
       const ws = new this.configuration.WebSocketPolyfill(this.url)
       ws.binaryType = 'arraybuffer'
-      ws.onmessage = (payload: any) => this.emit('message', payload)
-      ws.onclose = (payload: any) => this.emit('close', { event: payload })
-      ws.onopen = (payload: any) => this.emit('open', payload)
-      ws.onerror = (err: any) => {
-        reject(err)
-      }
+      ws.identifier = this.identifier
+
+      this.attachWebSocketListeners(ws, reject)
+
       this.webSocket = ws
 
       // Reset the status
@@ -363,7 +406,10 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     }
 
     // Don’t close the connection when a message was received recently
-    if (this.configuration.messageReconnectTimeout >= time.getUnixTime() - this.lastMessageReceived) {
+    if (
+      this.configuration.messageReconnectTimeout
+      >= time.getUnixTime() - this.lastMessageReceived
+    ) {
       return
     }
 
@@ -384,15 +430,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
       this.webSocket?.close()
       this.messageQueue = []
     }
-
-  }
-
-  registerEventListeners() {
-    if (typeof window === 'undefined') {
-      return
-    }
-
-    window.addEventListener('online', this.boundConnect)
   }
 
   // Ensure that the URL always ends with /
@@ -435,7 +472,7 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   onClose({ event }: onCloseParameters) {
     this.closeTries = 0
-    this.webSocket = null
+    this.cleanupWebSocket()
 
     if (this.status === WebSocketStatus.Connected) {
       this.status = WebSocketStatus.Disconnected
@@ -445,9 +482,13 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
     if (event.code === Unauthorized.code) {
       if (event.reason === Unauthorized.reason) {
-        console.warn('[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.')
+        console.warn(
+          '[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.',
+        )
       } else {
-        console.warn(`[HocuspocusProvider] Connection closed with status Unauthorized: ${event.reason}`)
+        console.warn(
+          `[HocuspocusProvider] Connection closed with status Unauthorized: ${event.reason}`,
+        )
       }
 
       this.shouldConnect = false
@@ -455,13 +496,17 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
     if (event.code === Forbidden.code) {
       if (!this.configuration.quiet) {
-        console.warn('[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.')
+        console.warn(
+          '[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.',
+        )
         return // TODO REMOVE ME
       }
     }
 
     if (event.code === MessageTooBig.code) {
-      console.warn(`[HocuspocusProvider] Connection closed with status MessageTooBig: ${event.reason}`)
+      console.warn(
+        `[HocuspocusProvider] Connection closed with status MessageTooBig: ${event.reason}`,
+      )
       this.shouldConnect = false
     }
 
@@ -507,11 +552,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
     this.removeAllListeners()
 
-    if (typeof window === 'undefined') {
-      return
-    }
-
-    window.removeEventListener('online', this.boundConnect)
+    this.cleanupWebSocket()
   }
-
 }

package/src/TiptapCollabProvider.ts

@@ -5,6 +5,7 @@ import {
 } from './HocuspocusProvider.js'
 
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js'
+import type { THistoryVersion } from './types'
 
 export type TiptapCollabProviderConfiguration =
   Required<Pick<HocuspocusProviderConfiguration, 'name'>> &
@@ -21,12 +22,6 @@ export interface AdditionalTiptapCollabProviderConfiguration {
   websocketProvider?: TiptapCollabProviderWebsocket
 }
 
-export type AuditHistoryVersion = {
-  name?: string;
-  version: number;
-  date: number;
-}
-
 export class TiptapCollabProvider extends HocuspocusProvider {
   tiptapCollabConfigurationPrefix = '__tiptapcollab__'
 
@@ -42,43 +37,53 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     super(configuration as HocuspocusProviderConfiguration)
   }
 
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   */
   createVersion(name?: string) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return this.sendStateless(JSON.stringify({ action: 'version.create', name }))
   }
 
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   */
   revertToVersion(targetVersion: number) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.sendStateless(JSON.stringify({ action: 'version.revert', version: targetVersion }))
+    return this.sendStateless(JSON.stringify({ action: 'document.revert', version: targetVersion }))
   }
 
-  getVersions(): AuditHistoryVersion[] {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.configuration.document.getArray<AuditHistoryVersion>(`${this.tiptapCollabConfigurationPrefix}versions`).toArray()
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   *
+   * The server will reply with a stateless message (THistoryVersionPreviewEvent)
+   */
+  previewVersion(targetVersion: number) {
+    return this.sendStateless(JSON.stringify({ action: 'version.preview', version: targetVersion }))
+  }
+
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   */
+  getVersions(): THistoryVersion[] {
+    return this.configuration.document.getArray<THistoryVersion>(`${this.tiptapCollabConfigurationPrefix}versions`).toArray()
   }
 
-  watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.configuration.document.getArray<AuditHistoryVersion>('__tiptapcollab__versions').observe(callback)
+  watchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['observe']>[0]) {
+    return this.configuration.document.getArray<THistoryVersion>('__tiptapcollab__versions').observe(callback)
   }
 
-  unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.configuration.document.getArray<AuditHistoryVersion>('__tiptapcollab__versions').unobserve(callback)
+  unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['unobserve']>[0]) {
+    return this.configuration.document.getArray<THistoryVersion>('__tiptapcollab__versions').unobserve(callback)
   }
 
   isAutoVersioning(): boolean {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return !!this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).get('autoVersioning')
   }
 
   enableAutoVersioning() {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 1)
   }
 
   disableAutoVersioning() {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 0)
   }
 

package/src/types.ts

@@ -103,3 +103,66 @@ export type onStatelessParameters = {
 }
 
 export type StatesArray = { clientId: number, [key: string | number]: any }[]
+
+// hocuspocus-pro types
+
+export type THistoryVersion = {
+  name?: string;
+  version: number;
+  date: number;
+};
+
+export type THistoryConfiguration = {
+  autoVersioning: boolean;
+  currentVersion: number;
+  stateCaptured: number; // indicates whether changes have been made since the last version
+};
+
+export type THistoryAction =
+  | THistoryDocumentRevertAction
+  | THistoryVersionCreateAction
+  | THistoryVersionPreviewAction;
+
+export type THistoryDocumentRevertAction = {
+  action: 'document.revert';
+  /**
+   * if changes havent been persisted to a version yet, we'll create one with the specified name,
+   * expect when `false` is passed.
+   */
+  currentVersionName?: string | false;
+  /**
+   * Name of the version that is created after the revert. Pass `false` to avoid generating a new version.
+   */
+  newVersionName?: string | false;
+};
+
+export type THistoryVersionCreateAction = {
+  action: 'version.create';
+  name?: string;
+};
+
+export type THistoryVersionPreviewAction = {
+  action: 'version.preview';
+  version: number;
+};
+
+export type THistoryEvent =
+  | THistoryVersionPreviewEvent
+  | THistoryVersionCreatedEvent
+  | THistoryDocumentRevertedEvent;
+
+export type THistoryVersionCreatedEvent = {
+  event: 'version.created';
+  version: number;
+};
+
+export type THistoryVersionPreviewEvent = {
+  event: 'version.preview';
+  version: number;
+  ydoc: string; // base64-encoded Uint8Array
+};
+
+export type THistoryDocumentRevertedEvent = {
+  event: 'document.reverted';
+  version: number;
+};