@atlaskit/collab-provider 9.1.0 → 9.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/collab-provider
 
+## 9.2.0
+
+### Minor Changes
+
+- [`ef726a72028`](https://bitbucket.org/atlassian/atlassian-frontend/commits/ef726a72028) - adding provider catchup when initial draft timestamp exceeds stale timeout
+
 ## 9.1.0
 
 ### Minor Changes

package/dist/cjs/provider/index.js

@@ -30,6 +30,7 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 var logger = (0, _utils.createLogger)('Provider', 'black');
 var OUT_OF_SYNC_PERIOD = 3 * 1000; // 3 seconds
+var PRELOAD_DRAFT_SYNC_PERIOD = 15 * 1000; // 15 seconds
 
 var MAX_STEP_REJECTED_ERROR = 15;
 exports.MAX_STEP_REJECTED_ERROR = MAX_STEP_REJECTED_ERROR;
@@ -75,20 +76,27 @@ var Provider = /*#__PURE__*/function (_Emitter) {
           sid: sid,
           initial: !initialized
         });
-        // If initial draft is already present and the channel is initialized,
-        // fire the provider's init event with initial draft document and version
+
+        // Early initialization with initial draft passed via provider
         if (_this.initialDraft && initialized && !_this.isProviderInitialized) {
-          var _this$initialDraft = _this.initialDraft,
-            document = _this$initialDraft.document,
-            version = _this$initialDraft.version,
-            metadata = _this$initialDraft.metadata;
-          // Initial document, version, metadata from initial draft
-          _this.documentService.updateDocument({
-            doc: document,
-            version: version,
-            metadata: metadata
-          });
-          _this.metadataService.updateMetadata(metadata);
+          // Call catchup if the draft has become stale since being passed to provider
+          if (_this.isDraftTimestampStale()) {
+            _this.documentService.throttledCatchup();
+          }
+          // If the initial draft is already up to date, update the document with that of the initial draft
+          else {
+            var _this$initialDraft = _this.initialDraft,
+              document = _this$initialDraft.document,
+              version = _this$initialDraft.version,
+              metadata = _this$initialDraft.metadata;
+            // Initial document, version, metadata from initial draft
+            _this.documentService.updateDocument({
+              doc: document,
+              version: version,
+              metadata: metadata
+            });
+            _this.metadataService.updateMetadata(metadata);
+          }
           _this.isProviderInitialized = true;
         }
         // If already initialized, `connected` means reconnected
@@ -316,6 +324,21 @@ var Provider = /*#__PURE__*/function (_Emitter) {
       }
     }
 
+    /**
+     * Checks the provider's initial draft timestamp to determine if it is stale.
+     * Returns true only if the time elapsed since the draft timestamp is greater than or
+     * equal to a predetermined timeout. Returns false in all other cases.
+     */
+  }, {
+    key: "isDraftTimestampStale",
+    value: function isDraftTimestampStale() {
+      var _this$initialDraft2;
+      if (!((_this$initialDraft2 = this.initialDraft) !== null && _this$initialDraft2 !== void 0 && _this$initialDraft2.timestamp)) {
+        return false;
+      }
+      return Date.now() - this.initialDraft.timestamp >= PRELOAD_DRAFT_SYNC_PERIOD;
+    }
+
     /**
      * Send steps from transaction to NCS (and as a consequence to other participants), called from the collab-edit plugin in the editor
      * @param {Transaction} _tr Deprecated, included to keep API consistent with Synchrony provider

package/dist/cjs/version-wrapper.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.version = exports.nextMajorVersion = exports.name = void 0;
 var name = "@atlaskit/collab-provider";
 exports.name = name;
-var version = "9.1.0";
+var version = "9.2.0";
 exports.version = version;
 var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/collab-provider",
-	"version": "9.1.0",
+	"version": "9.2.0",
 	"sideEffects": false
 }

package/dist/es2019/provider/index.js

@@ -12,6 +12,7 @@ import { ParticipantsService } from '../participants/participants-service';
 import { errorCodeMapper } from '../errors/error-code-mapper';
 const logger = createLogger('Provider', 'black');
 const OUT_OF_SYNC_PERIOD = 3 * 1000; // 3 seconds
+const PRELOAD_DRAFT_SYNC_PERIOD = 15 * 1000; // 15 seconds
 
 export const MAX_STEP_REJECTED_ERROR = 15;
 export class Provider extends Emitter {
@@ -51,21 +52,28 @@ export class Provider extends Emitter {
           sid,
           initial: !initialized
         });
-        // If initial draft is already present and the channel is initialized,
-        // fire the provider's init event with initial draft document and version
+
+        // Early initialization with initial draft passed via provider
         if (this.initialDraft && initialized && !this.isProviderInitialized) {
-          const {
-            document,
-            version,
-            metadata
-          } = this.initialDraft;
-          // Initial document, version, metadata from initial draft
-          this.documentService.updateDocument({
-            doc: document,
-            version,
-            metadata
-          });
-          this.metadataService.updateMetadata(metadata);
+          // Call catchup if the draft has become stale since being passed to provider
+          if (this.isDraftTimestampStale()) {
+            this.documentService.throttledCatchup();
+          }
+          // If the initial draft is already up to date, update the document with that of the initial draft
+          else {
+            const {
+              document,
+              version,
+              metadata
+            } = this.initialDraft;
+            // Initial document, version, metadata from initial draft
+            this.documentService.updateDocument({
+              doc: document,
+              version,
+              metadata
+            });
+            this.metadataService.updateMetadata(metadata);
+          }
           this.isProviderInitialized = true;
         }
         // If already initialized, `connected` means reconnected
@@ -261,6 +269,19 @@ export class Provider extends Emitter {
     }
   }
 
+  /**
+   * Checks the provider's initial draft timestamp to determine if it is stale.
+   * Returns true only if the time elapsed since the draft timestamp is greater than or
+   * equal to a predetermined timeout. Returns false in all other cases.
+   */
+  isDraftTimestampStale() {
+    var _this$initialDraft;
+    if (!((_this$initialDraft = this.initialDraft) !== null && _this$initialDraft !== void 0 && _this$initialDraft.timestamp)) {
+      return false;
+    }
+    return Date.now() - this.initialDraft.timestamp >= PRELOAD_DRAFT_SYNC_PERIOD;
+  }
+
   /**
    * Send steps from transaction to NCS (and as a consequence to other participants), called from the collab-edit plugin in the editor
    * @param {Transaction} _tr Deprecated, included to keep API consistent with Synchrony provider

package/dist/es2019/version-wrapper.js

@@ -1,5 +1,5 @@
 export const name = "@atlaskit/collab-provider";
-export const version = "9.1.0";
+export const version = "9.2.0";
 export const nextMajorVersion = () => {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/collab-provider",
-	"version": "9.1.0",
+	"version": "9.2.0",
 	"sideEffects": false
 }

package/dist/esm/provider/index.js

@@ -23,6 +23,7 @@ import { ParticipantsService } from '../participants/participants-service';
 import { errorCodeMapper } from '../errors/error-code-mapper';
 var logger = createLogger('Provider', 'black');
 var OUT_OF_SYNC_PERIOD = 3 * 1000; // 3 seconds
+var PRELOAD_DRAFT_SYNC_PERIOD = 15 * 1000; // 15 seconds
 
 export var MAX_STEP_REJECTED_ERROR = 15;
 export var Provider = /*#__PURE__*/function (_Emitter) {
@@ -67,20 +68,27 @@ export var Provider = /*#__PURE__*/function (_Emitter) {
           sid: sid,
           initial: !initialized
         });
-        // If initial draft is already present and the channel is initialized,
-        // fire the provider's init event with initial draft document and version
+
+        // Early initialization with initial draft passed via provider
         if (_this.initialDraft && initialized && !_this.isProviderInitialized) {
-          var _this$initialDraft = _this.initialDraft,
-            document = _this$initialDraft.document,
-            version = _this$initialDraft.version,
-            metadata = _this$initialDraft.metadata;
-          // Initial document, version, metadata from initial draft
-          _this.documentService.updateDocument({
-            doc: document,
-            version: version,
-            metadata: metadata
-          });
-          _this.metadataService.updateMetadata(metadata);
+          // Call catchup if the draft has become stale since being passed to provider
+          if (_this.isDraftTimestampStale()) {
+            _this.documentService.throttledCatchup();
+          }
+          // If the initial draft is already up to date, update the document with that of the initial draft
+          else {
+            var _this$initialDraft = _this.initialDraft,
+              document = _this$initialDraft.document,
+              version = _this$initialDraft.version,
+              metadata = _this$initialDraft.metadata;
+            // Initial document, version, metadata from initial draft
+            _this.documentService.updateDocument({
+              doc: document,
+              version: version,
+              metadata: metadata
+            });
+            _this.metadataService.updateMetadata(metadata);
+          }
           _this.isProviderInitialized = true;
         }
         // If already initialized, `connected` means reconnected
@@ -308,6 +316,21 @@ export var Provider = /*#__PURE__*/function (_Emitter) {
       }
     }
 
+    /**
+     * Checks the provider's initial draft timestamp to determine if it is stale.
+     * Returns true only if the time elapsed since the draft timestamp is greater than or
+     * equal to a predetermined timeout. Returns false in all other cases.
+     */
+  }, {
+    key: "isDraftTimestampStale",
+    value: function isDraftTimestampStale() {
+      var _this$initialDraft2;
+      if (!((_this$initialDraft2 = this.initialDraft) !== null && _this$initialDraft2 !== void 0 && _this$initialDraft2.timestamp)) {
+        return false;
+      }
+      return Date.now() - this.initialDraft.timestamp >= PRELOAD_DRAFT_SYNC_PERIOD;
+    }
+
     /**
      * Send steps from transaction to NCS (and as a consequence to other participants), called from the collab-edit plugin in the editor
      * @param {Transaction} _tr Deprecated, included to keep API consistent with Synchrony provider

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/collab-provider";
-export var version = "9.1.0";
+export var version = "9.2.0";
 export var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/collab-provider",
-	"version": "9.1.0",
+	"version": "9.2.0",
 	"sideEffects": false
 }

package/dist/types/provider/index.d.ts

@@ -59,6 +59,12 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
         onSyncUpError?: SyncUpErrorFunction;
     }): this;
     private checkForCookies;
+    /**
+     * Checks the provider's initial draft timestamp to determine if it is stale.
+     * Returns true only if the time elapsed since the draft timestamp is greater than or
+     * equal to a predetermined timeout. Returns false in all other cases.
+     */
+    private isDraftTimestampStale;
     /**
      * Send steps from transaction to NCS (and as a consequence to other participants), called from the collab-edit plugin in the editor
      * @param {Transaction} _tr Deprecated, included to keep API consistent with Synchrony provider

package/dist/types/types.d.ts

@@ -61,6 +61,7 @@ export interface InitialDraft {
     document: JSONDocNode;
     version: number;
     metadata?: Metadata;
+    timestamp?: number;
 }
 export interface Config {
     url: string;

package/dist/types-ts4.5/provider/index.d.ts

@@ -59,6 +59,12 @@ export declare class Provider extends Emitter<CollabEvents> implements BaseEvent
         onSyncUpError?: SyncUpErrorFunction;
     }): this;
     private checkForCookies;
+    /**
+     * Checks the provider's initial draft timestamp to determine if it is stale.
+     * Returns true only if the time elapsed since the draft timestamp is greater than or
+     * equal to a predetermined timeout. Returns false in all other cases.
+     */
+    private isDraftTimestampStale;
     /**
      * Send steps from transaction to NCS (and as a consequence to other participants), called from the collab-edit plugin in the editor
      * @param {Transaction} _tr Deprecated, included to keep API consistent with Synchrony provider

package/dist/types-ts4.5/types.d.ts

@@ -61,6 +61,7 @@ export interface InitialDraft {
     document: JSONDocNode;
     version: number;
     metadata?: Metadata;
+    timestamp?: number;
 }
 export interface Config {
     url: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/collab-provider",
-  "version": "9.1.0",
+  "version": "9.2.0",
   "description": "A provider for collaborative editing.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -25,7 +25,7 @@
   "atlassian": {
     "team": "Editor Services",
     "inPublicMirror": true,
-    "releaseModel": "scheduled"
+    "releaseModel": "continuous"
   },
   "af:exports": {
     ".": "./src/index.ts",

package/report.api.md

@@ -354,6 +354,8 @@ interface InitialDraft {
   // (undocumented)
   metadata?: Metadata_2;
   // (undocumented)
+  timestamp?: number;
+  // (undocumented)
   version: number;
 }
 

package/tmp/api-report-tmp.d.ts

@@ -0,0 +1,564 @@
+## API Report File for "@atlaskit/collab-provider"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { AnalyticsWebClient } from '@atlaskit/analytics-listeners';
+import type { EditorState } from 'prosemirror-state';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { Manager } from 'socket.io-client';
+import type { Step } from 'prosemirror-transform';
+import type { Transaction } from 'prosemirror-state';
+
+// @public (undocumented)
+type AuthCallback = (cb: (data: InitAndAuthData) => void) => void;
+
+// @public (undocumented)
+type BaseEvents = Pick<CollabEditProvider<CollabEvents>, 'send' | 'sendMessage' | 'setup'>;
+
+// @public (undocumented)
+type CollabCommitStatusEventPayload = {
+    status: 'attempt' | 'failure' | 'success';
+    version: number;
+};
+
+// @public (undocumented)
+export type CollabConnectedPayload = CollabEventConnectionData;
+
+// @public (undocumented)
+type CollabConnectingPayload = CollabEventConnectingData;
+
+// @public (undocumented)
+export interface CollabDataPayload extends CollabEventRemoteData {
+    // (undocumented)
+    json: StepJson[];
+    // (undocumented)
+    userIds: (number | string)[];
+    // (undocumented)
+    version: number;
+}
+
+// @public (undocumented)
+export interface CollabDisconnectedPayload {
+    // (undocumented)
+    reason: DisconnectReason;
+    // (undocumented)
+    sid: string;
+}
+
+// @public (undocumented)
+export interface CollabEditProvider<Events extends CollabEvents = CollabEvents> {
+    // (undocumented)
+    getFinalAcknowledgedState(): Promise<ResolvedEditorState>;
+    // (undocumented)
+    initialize(getState: () => any, createStep: (json: object) => Step): this;
+    // (undocumented)
+    off(evt: keyof Events, handler: (...args: any) => void): this;
+    // (undocumented)
+    on(evt: keyof Events, handler: (...args: any) => void): this;
+    // (undocumented)
+    send(tr: Transaction, oldState: EditorState, newState: EditorState): void;
+    // (undocumented)
+    sendMessage<K extends keyof Events>(data: {
+        type: K;
+    } & Events[K]): void;
+    // (undocumented)
+    setup(props: {
+        getState?: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+    }): this;
+    // (undocumented)
+    unsubscribeAll(evt: keyof Events): this;
+}
+
+// @public (undocumented)
+export interface CollabEventConnectingData {
+    // (undocumented)
+    initial: boolean;
+}
+
+// @public (undocumented)
+export interface CollabEventConnectionData {
+    // (undocumented)
+    initial: boolean;
+    // (undocumented)
+    sid: string;
+}
+
+// @public (undocumented)
+export interface CollabEventDisconnectedData {
+    // (undocumented)
+    reason: 'CLIENT_DISCONNECT' | 'SERVER_DISCONNECT' | 'SOCKET_CLOSED' | 'SOCKET_ERROR' | 'SOCKET_TIMEOUT' | 'UNKNOWN_DISCONNECT';
+    // (undocumented)
+    sid: string;
+}
+
+// @public (undocumented)
+export interface CollabEventInitData {
+    // (undocumented)
+    doc?: any;
+    // (undocumented)
+    json?: any;
+    // (undocumented)
+    reserveCursor?: boolean;
+    // (undocumented)
+    sid?: string;
+    // (undocumented)
+    version?: number;
+}
+
+// @public (undocumented)
+export interface CollabEventLocalStepData {
+    // (undocumented)
+    steps: Array<Step>;
+}
+
+// @public (undocumented)
+export interface CollabEventPresenceData {
+    // (undocumented)
+    joined?: CollabParticipant[];
+    // (undocumented)
+    left?: {
+        sessionId: string;
+    }[];
+}
+
+// @public (undocumented)
+export interface CollabEventRemoteData {
+    // (undocumented)
+    json?: any;
+    // (undocumented)
+    newState?: EditorState;
+    // (undocumented)
+    userIds?: (number | string)[];
+}
+
+// @public (undocumented)
+export interface CollabEvents {
+    // (undocumented)
+    'commit-status': CollabCommitStatusEventPayload;
+    // (undocumented)
+    'local-steps': CollabLocalStepsPayload;
+    // (undocumented)
+    'metadata:changed': CollabMetadataPayload;
+    // (undocumented)
+    connected: CollabConnectedPayload;
+    // (undocumented)
+    connecting: CollabConnectingPayload;
+    // (undocumented)
+    data: CollabDataPayload;
+    // (undocumented)
+    disconnected: CollabDisconnectedPayload;
+    // (undocumented)
+    entity: any;
+    // (undocumented)
+    error: ProviderError;
+    // (undocumented)
+    init: CollabInitPayload;
+    // (undocumented)
+    presence: CollabPresencePayload;
+    // (undocumented)
+    telepointer: CollabTelepointerPayload;
+}
+
+// @public (undocumented)
+export interface CollabEventTelepointerData {
+    // (undocumented)
+    selection: CollabSendableSelection;
+    // (undocumented)
+    sessionId: string;
+    // (undocumented)
+    type: 'telepointer';
+}
+
+// @public (undocumented)
+export interface CollabInitPayload extends CollabEventInitData {
+    // (undocumented)
+    doc: any;
+    // (undocumented)
+    metadata?: Metadata_2;
+    // (undocumented)
+    reserveCursor?: boolean;
+    // (undocumented)
+    version: number;
+}
+
+// @public (undocumented)
+export type CollabLocalStepsPayload = {
+    steps: readonly Step[];
+};
+
+// @public (undocumented)
+export type CollabMetadataPayload = Metadata_2;
+
+// @public (undocumented)
+export interface CollabParticipant {
+    // (undocumented)
+    avatar: string;
+    // (undocumented)
+    cursorPos?: number;
+    // (undocumented)
+    lastActive: number;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    sessionId: string;
+}
+
+// @public (undocumented)
+export type CollabPresencePayload = CollabEventPresenceData;
+
+// @public (undocumented)
+export interface CollabSendableSelection {
+    // (undocumented)
+    anchor?: number | string;
+    // (undocumented)
+    head?: number | string;
+    // (undocumented)
+    type: 'nodeSelection' | 'textSelection';
+}
+
+// @public (undocumented)
+export type CollabTelepointerPayload = CollabEventTelepointerData;
+
+// @public (undocumented)
+interface Config {
+    analyticsClient?: AnalyticsWebClient;
+    // (undocumented)
+    cacheToken?: boolean;
+    // (undocumented)
+    createSocket: (path: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation) => Socket;
+    // (undocumented)
+    documentAri: string;
+    failedStepLimitBeforeCatchupOnPublish?: number;
+    // (undocumented)
+    featureFlags?: {
+        [key: string]: boolean;
+    };
+    // (undocumented)
+    getAnalyticsWebClient?: Promise<AnalyticsWebClient>;
+    // (undocumented)
+    getUser?(userId: string): Promise<Pick<ProviderParticipant, 'avatar' | 'name' | 'userId'>>;
+    // (undocumented)
+    initialDraft?: InitialDraft;
+    // (undocumented)
+    lifecycle?: Lifecycle;
+    // (undocumented)
+    need404?: boolean;
+    permissionTokenRefresh?: () => Promise<null | string>;
+    // (undocumented)
+    productInfo?: ProductInformation;
+    // (undocumented)
+    storage?: Storage_2;
+    throwOnNotConnected?: boolean;
+    // (undocumented)
+    url: string;
+}
+
+// @public (undocumented)
+enum DisconnectReason {
+    // (undocumented)
+    CLIENT_DISCONNECT = "CLIENT_DISCONNECT",
+    // (undocumented)
+    SERVER_DISCONNECT = "SERVER_DISCONNECT",
+    // (undocumented)
+    SOCKET_CLOSED = "SOCKET_CLOSED",
+    // (undocumented)
+    SOCKET_ERROR = "SOCKET_ERROR",
+    // (undocumented)
+    SOCKET_TIMEOUT = "SOCKET_TIMEOUT",
+    // (undocumented)
+    UNKNOWN_DISCONNECT = "UNKNOWN_DISCONNECT"
+}
+
+// @public
+type DocumentNotFound = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_NOT_FOUND;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+
+// @public
+type DocumentNotRestore = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_RESTORE_ERROR;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+
+// @public (undocumented)
+class Emitter<T = any> {
+    protected emit<K extends keyof T>(evt: K, data: T[K]): this;
+    off<K extends keyof T>(evt: K, handler: (args: T[K]) => void): this;
+    on<K extends keyof T>(evt: K, handler: (args: T[K]) => void): this;
+    unsubscribeAll<K extends keyof T>(evt?: K): this;
+}
+
+// @public (undocumented)
+type EventHandler = () => void;
+
+// @public
+type FailToSave = {
+    code: PROVIDER_ERROR_CODE.FAIL_TO_SAVE;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+
+// @public (undocumented)
+interface InitAndAuthData {
+    // (undocumented)
+    initialized: boolean;
+    // (undocumented)
+    need404?: boolean;
+    // (undocumented)
+    token?: string;
+}
+
+// @public (undocumented)
+interface InitialDraft {
+    // (undocumented)
+    document: JSONDocNode;
+    // (undocumented)
+    metadata?: Metadata_2;
+    // (undocumented)
+    timestamp?: number;
+    // (undocumented)
+    version: number;
+}
+
+// @public
+type InitialisationError = {
+    code: PROVIDER_ERROR_CODE.INITIALISATION_ERROR;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+
+// @public
+type InsufficientEditingPermission = {
+    code: PROVIDER_ERROR_CODE.NO_PERMISSION_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason?: string;
+    status?: number;
+};
+
+// @public
+type InternalServiceError = {
+    code: PROVIDER_ERROR_CODE.INTERNAL_SERVICE_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    status?: number;
+};
+
+// @public
+type InvalidProviderConfiguration = {
+    code: PROVIDER_ERROR_CODE.INVALID_PROVIDER_CONFIGURATION;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    status?: number;
+};
+
+// @public
+type InvalidUserToken = {
+    code: PROVIDER_ERROR_CODE.INVALID_USER_TOKEN;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+
+// @public (undocumented)
+interface Lifecycle {
+    // (undocumented)
+    on(event: LifecycleEvents, handler: EventHandler): void;
+}
+
+// @public (undocumented)
+type LifecycleEvents = 'restore' | 'save';
+
+// @public
+type Locked = {
+    code: PROVIDER_ERROR_CODE.LOCKED;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+
+// @public (undocumented)
+type MarkJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+};
+
+// @public (undocumented)
+interface Metadata_2 {
+    // (undocumented)
+    [key: string]: boolean | number | string;
+}
+
+// @public
+type NetworkIssue = {
+    code: PROVIDER_ERROR_CODE.NETWORK_ISSUE;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+
+// @public (undocumented)
+export type NewCollabSyncUpErrorAttributes = {
+    lengthOfUnconfirmedSteps?: number;
+    tries: number;
+    maxRetries: number;
+    clientId?: number | string;
+    version: number;
+};
+
+// @public (undocumented)
+type NodeJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+    content: NodeJson[];
+    marks: MarkJson[];
+    text?: string;
+};
+
+// @public (undocumented)
+type ProductInformation = {
+    product: string;
+    subProduct?: string;
+};
+
+// @public (undocumented)
+export class Provider extends Emitter<CollabEvents> implements BaseEvents {
+    constructor(config: Config);
+    destroy(): this;
+    // @deprecated
+    disconnect(): this;
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
+    getMetadata: () => Metadata_2;
+    // (undocumented)
+    getStatePromiseResolve: (value: PromiseLike<void> | void) => void;
+    // (undocumented)
+    getUnconfirmedSteps: () => readonly Step[] | undefined;
+    // @deprecated
+    initialize(getState: () => EditorState): this;
+    send(_tr: Transaction | null, _oldState: EditorState | null, newState: EditorState): void;
+    sendMessage(data: CollabTelepointerPayload): void;
+    // @deprecated
+    setEditorWidth(editorWidth: string, broadcast?: boolean): void;
+    setMetadata(metadata: Metadata_2): void;
+    // @deprecated
+    setTitle(title: string, broadcast?: boolean): void;
+    setup({ getState, onSyncUpError, }: {
+        getState?: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+    }): this;
+    // @deprecated
+    unsubscribeAll(): this;
+}
+
+// @public (undocumented)
+export enum PROVIDER_ERROR_CODE {
+    // (undocumented)
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    // (undocumented)
+    DOCUMENT_RESTORE_ERROR = "DOCUMENT_RESTORE_ERROR",
+    // (undocumented)
+    FAIL_TO_SAVE = "FAIL_TO_SAVE",
+    // (undocumented)
+    INITIALISATION_ERROR = "INITIALISATION_ERROR",
+    // (undocumented)
+    INTERNAL_SERVICE_ERROR = "INTERNAL_SERVICE_ERROR",
+    // (undocumented)
+    INVALID_PROVIDER_CONFIGURATION = "INVALID_PROVIDER_CONFIGURATION",
+    // (undocumented)
+    INVALID_USER_TOKEN = "INVALID_USER_TOKEN",
+    // (undocumented)
+    LOCKED = "LOCKED",
+    // (undocumented)
+    NETWORK_ISSUE = "NETWORK_ISSUE",
+    // (undocumented)
+    NO_PERMISSION_ERROR = "NO_PERMISSION_ERROR"
+}
+
+// @public
+export type ProviderError = DocumentNotFound | DocumentNotRestore | FailToSave | InitialisationError | InsufficientEditingPermission | InternalServiceError | InvalidProviderConfiguration | InvalidUserToken | Locked | NetworkIssue;
+
+// @public (undocumented)
+type ProviderParticipant = CollabParticipant & {
+    userId: string;
+    clientId: number | string;
+};
+
+// @public (undocumented)
+export type ResolvedEditorState<T = any> = {
+    content: JSONDocNode | T;
+    title: null | string;
+    stepVersion: number;
+};
+
+// @public (undocumented)
+interface SimpleEventEmitter {
+    // (undocumented)
+    on(event: string, fn: Function): SimpleEventEmitter;
+}
+
+// @public (undocumented)
+type SliceJson = {
+    content: NodeJson[];
+    openStart: number;
+    openEnd: number;
+};
+
+// @public (undocumented)
+export interface Socket extends SimpleEventEmitter {
+    // (undocumented)
+    close(): Socket;
+    // (undocumented)
+    connect(): Socket;
+    // (undocumented)
+    emit(event: string, ...args: any[]): Socket;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    io?: Manager;
+}
+
+// @public (undocumented)
+type StepJson = {
+    stepType?: string;
+    from?: number;
+    to?: number;
+    slice?: SliceJson;
+    clientId: number | string;
+    userId: string;
+    createdAt?: number;
+    structure?: boolean;
+};
+
+// @public (undocumented)
+interface Storage_2 {
+    // (undocumented)
+    delete(key: string): Promise<void>;
+    // (undocumented)
+    get(key: string): Promise<string>;
+    // (undocumented)
+    set(key: string, value: string): Promise<void>;
+}
+
+// @public (undocumented)
+export type SyncUpErrorFunction = (attributes: NewCollabSyncUpErrorAttributes) => void;
+
+// (No @packageDocumentation comment for this package)
+
+```