@atlaskit/collab-provider 8.8.0 → 8.8.1

package/dist/types-ts4.0/participants/participants-helper.d.ts

@@ -0,0 +1,14 @@
+import type { CollabEventPresenceData, CollabParticipant } from '@atlaskit/editor-common/collab';
+import type { CollabEventTelepointerData, PresencePayload } from '../types';
+export declare const PARTICIPANT_UPDATE_INTERVAL: number;
+export declare type ProviderParticipant = CollabParticipant & {
+    userId: string;
+    clientId: number | string;
+};
+export declare type ParticipantsMap = Map<string, ProviderParticipant>;
+export declare type PresenceEmit = (evt: 'presence', data: CollabEventPresenceData) => void;
+export declare type TelepointerEmit = (evt: 'telepointer', data: CollabEventTelepointerData) => void;
+export declare type GetUserType = ((userId: string) => Promise<Pick<ProviderParticipant, 'name' | 'avatar' | 'userId'>>) | undefined;
+export declare const createParticipantFromPayload: (payload: PresencePayload & {
+    userId: string;
+}, getUser: GetUserType) => Promise<ProviderParticipant>;

package/dist/types-ts4.0/participants/participants-service.d.ts

@@ -0,0 +1,70 @@
+import type { CollabEventPresenceData, CollabEventDisconnectedData } from '@atlaskit/editor-common/collab';
+import AnalyticsHelper from '../analytics/analytics-helper';
+import type { CollabEventTelepointerData, PresencePayload, StepJson, TelepointerPayload } from '../types';
+import { GetUserType, TelepointerEmit } from './participants-helper';
+import type { PresenceEmit } from './participants-helper';
+import { ParticipantsState } from './participants-state';
+export declare class ParticipantsService {
+    private participantsState;
+    private participantUpdateTimeout;
+    private analyticsHelper;
+    constructor(analyticsHelper: AnalyticsHelper | undefined, participantsState?: ParticipantsState);
+    /**
+     * Carries out 3 things: 1) enriches the participant with user data, 2) updates the participantsState, 3) emits the presence event
+     * @param payload Payload from incoming socket event
+     * @param getUser Function to get user data from confluence
+     * @param emit Function to execute emit from provider socket
+     * @returns Awaitable Promise, due to getUser
+     */
+    updateParticipant: (payload: PresencePayload, getUser: GetUserType, emit: PresenceEmit) => Promise<void>;
+    /**
+     * Called when a participant leaves the session.
+     *
+     * We emit the `presence` event to update the active avatars in the editor.
+     */
+    participantLeft: ({ sessionId }: PresencePayload, emit: PresenceEmit) => void;
+    disconnect: (reason: string, sessionId: string | undefined, emit: (evt: 'presence' | 'disconnected', data: CollabEventPresenceData | CollabEventDisconnectedData) => void) => void;
+    /**
+     * Updates when users were last active
+     * @param userIds Users in most recent steps
+     */
+    updateLastActive: (userIds?: string[]) => void;
+    /**
+     * Called on receiving steps, emits each step's telepointer
+     * @param steps Steps to extract telepointers from
+     * @param emit Provider emit function
+     */
+    emitTelepointersFromSteps(steps: StepJson[], emit: TelepointerEmit): void;
+    /**
+     * Called when we receive a telepointer update from another
+     * participant.
+     */
+    participantTelepointer: (payload: TelepointerPayload, thisSessionId: string | undefined, getUser: GetUserType, emit: (evt: 'telepointer' | 'presence', data: CollabEventTelepointerData | CollabEventPresenceData) => void) => void;
+    /**
+     * Every 5 minutes (PARTICIPANT_UPDATE_INTERVAL), removes inactive participants and emits the update to other participants.
+     * Needs to be kicked off in the Provider.
+     * @param sessionId SessionId from provider's connection
+     * @param emit Function to execute emit from provider socket
+     */
+    removeInactiveParticipants: (sessionId: string | undefined, emit: PresenceEmit) => void;
+    /**
+     * Keep list of participants up to date. Filter out inactive users etc.
+     */
+    private filterInactive;
+    /**
+     * Wrapper function to emit with error handling and analytics
+     * @param data Data to emit
+     * @param emit Emit function from Provider
+     */
+    private emitPresence;
+    /**
+     * Wrapper function to emit with error handling and analytics
+     * @param data Data to emit
+     * @param emit Emit function from Provider
+     */
+    private emitTelepointer;
+    /**
+     * Used when the provider is disconnected or destroyed to prevent perpetual timers from continuously running
+     */
+    clearTimers: () => void;
+}

package/dist/types-ts4.0/participants/participants-state.d.ts

@@ -0,0 +1,13 @@
+import { ParticipantsMap, ProviderParticipant } from './participants-helper';
+export declare class ParticipantsState {
+    private participants;
+    constructor(baseParticipants?: ParticipantsMap);
+    getBySessionId: (sessionId: string) => ProviderParticipant | undefined;
+    setBySessionId: (sessionId: string, participant: ProviderParticipant) => void;
+    getParticipants: () => ProviderParticipant[];
+    removeBySessionId: (sessionId: string) => boolean;
+    clear: () => void;
+    doesntHave: (sessionId: string) => boolean;
+    size: () => number;
+    updateLastActive: (now: number, userIds: string[]) => void;
+}

package/dist/types-ts4.0/participants/telepointers-helper.d.ts

@@ -0,0 +1,4 @@
+import type { AcknowledgementPayload, CollabEventTelepointerData, StepJson } from '../types';
+import { ProviderParticipant } from './participants-helper';
+export declare const telepointerFromStep: (participants: ProviderParticipant[], step: StepJson) => CollabEventTelepointerData | undefined;
+export declare const telepointerCallback: (documentAri: string) => (response: AcknowledgementPayload) => void;

package/dist/types-ts4.0/provider/commit-step.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="lodash" />
+import { ChannelEvent, StepsPayload } from '../types';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import AnalyticsHelper from '../analytics/analytics-helper';
+import type { InternalError } from '../errors/error-types';
+export declare const commitStep: ({ broadcast, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, }: {
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function | undefined) => void;
+    steps: readonly ProseMirrorStep[];
+    version: number;
+    userId: string;
+    clientId: number | string;
+    onStepsAdded: (data: StepsPayload) => void;
+    onErrorHandled: (error: InternalError) => void;
+    analyticsHelper?: AnalyticsHelper | undefined;
+}) => void;
+export declare const throttledCommitStep: import("lodash").DebouncedFunc<({ broadcast, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, }: {
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function | undefined) => void;
+    steps: readonly ProseMirrorStep[];
+    version: number;
+    userId: string;
+    clientId: number | string;
+    onStepsAdded: (data: StepsPayload) => void;
+    onErrorHandled: (error: InternalError) => void;
+    analyticsHelper?: AnalyticsHelper | undefined;
+}) => void>;

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

@@ -0,0 +1,162 @@
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import { Emitter } from '../emitter';
+import type { ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import type { CollabEditProvider, CollabEvents, CollabEventTelepointerData, Config, Metadata } from '../types';
+import type { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+export declare const MAX_STEP_REJECTED_ERROR = 15;
+declare type BaseEvents = Pick<CollabEditProvider<CollabEvents>, 'setup' | 'send' | 'sendMessage'>;
+export declare class Provider extends Emitter<CollabEvents> implements BaseEvents {
+    private channel;
+    private config;
+    private analyticsHelper?;
+    private isChannelInitialized;
+    private initialDraft?;
+    private isProviderInitialized;
+    private isNamespaceLocked;
+    private sessionId?;
+    private clientId?;
+    private userId?;
+    private presenceUpdateTimeout?;
+    private disconnectedAt?;
+    private readonly participantsService;
+    private readonly metadataService;
+    private readonly documentService;
+    private readonly emitCallback;
+    constructor(config: Config);
+    private initializeChannel;
+    /**
+     * Initialisation logic, called by Jira with a dummy getState function, deprecated in favour of the setup method which allows more configuration
+     * @param {Function} getState Function that returns the editor state, used to retrieve collab-edit properties and to interact with prosemirror-collab
+     * @throws {ProviderInitialisationError} Something went wrong during provider initialisation
+     * @deprecated Use setup method instead
+     */
+    initialize(getState: () => EditorState): this;
+    /**
+     * Initialisation logic, called by the editor in the collab-edit plugin
+     * @param {Object} parameters ...
+     * @param {Function} parameters.getState Function that returns the editor state, used to retrieve collab-edit properties and to interact with prosemirror-collab
+     * @param {SyncUpErrorFunction} parameters.onSyncUpError (Optional) Function that gets called when the sync of steps fails after retrying 30 times, used by Editor to log to analytics
+     * @throws {ProviderInitialisationError} Something went wrong during provider initialisation
+     */
+    setup({ getState, onSyncUpError, }: {
+        getState: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+    }): this;
+    private checkForCookies;
+    /**
+     * 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
+     * @param {EditorState} _oldState Deprecated, included to keep API consistent with Synchrony provider
+     * @param {EditorState} newState The editor state after applying the transaction
+     * @throws {SendTransactionError} Something went wrong while sending the steps for this transaction
+     */
+    send(_tr: Transaction | null, _oldState: EditorState | null, newState: EditorState): void;
+    /**
+     * @param {InternalError} error The error to handle
+     */
+    private onErrorHandled;
+    /**
+     * Send messages, such as telepointers, to NCS and other participants. Only used for telepointer data (text and node selections) in the editor and JWM. JWM does some weird serialisation stuff on the node selections.
+     * Silently fails if an error occurs, since Presence isn't a critical functionality and self-restores over time.
+     * @param {CollabEventTelepointerData} data Data you want to send to NCS / the other participants
+     * @param {string} data.type Can only be 'telepointer' for now, we don't support anything else yet
+     * @param {CollabSendableSelection} data.selection Object representing the selected element
+     * @param {string} data.sessionId Identifier identifying the session
+     */
+    sendMessage(data: CollabEventTelepointerData): void;
+    private sendPresence;
+    /**
+     * Called when a participant joins the session.
+     *
+     * We keep track of participants internally in this class, and emit the `presence` event to update
+     * the active avatars in the editor.
+     * This method will be triggered from backend to notify all participants to exchange presence
+     */
+    private onPresenceJoined;
+    private onPresence;
+    /**
+     * Called when a participant leaves the session.
+     *
+     * We emit the `presence` event to update the active avatars in the editor.
+     */
+    private onParticipantLeft;
+    private startInactiveRemover;
+    /**
+     * Called when we receive an update event from another participant.
+     */
+    private onParticipantUpdated;
+    /**
+     * Called when we receive a telepointer update from another
+     * participant.
+     */
+    private onParticipantTelepointer;
+    private onDisconnected;
+    /**
+     * "Destroy" the provider, disconnect it's connection to the back-end service and unsubscribe all event listeners on the provider.
+     * Used by Jira products (JWM, JPD) to disable the provider
+     * @throws {DestroyError} Something went wrong while shutting down the collab provider
+     */
+    destroy(): this;
+    /**
+     * Disconnect the provider, disconnect it's connection to the back-end service and unsubscribe all event listeners on the provider.
+     * Used by Confluence to disable the provider when a user doesn't have access to a resource.
+     * @deprecated use destroy instead, it does the same thing
+     * @throws {DestroyError} Something went wrong while shutting down the collab provider
+     */
+    disconnect(): this;
+    /**
+     * Disconnect the provider's connection to the back-end service and unsubscribe from all events emitted by this provider. Kept to keep roughly aligned to Synchrony API, which you need to call for each event.
+     * @deprecated use destroy instead, it does the same thing
+     * @throws {DestroyError} Something went wrong while shutting down the collab provider
+     */
+    unsubscribeAll(): this;
+    /**
+     * Update the title of the document in the collab provider and optionally broadcast it to other participants and NCS
+     * @deprecated use setMetadata instead, it does the same thing
+     * @param {string} title Title you want to set on the document
+     * @param {boolean} broadcast (Optional) Flag indicating whether you want to broadcast the title change to the other participants, always true for now (otherwise we would lose title changes)
+     * @throws {SetTitleError} Something went wrong while setting the title
+     */
+    setTitle(title: string, broadcast?: boolean): void;
+    /**
+     * Set editor width, not used any more
+     * @deprecated use setMetadata instead, it does the same thing
+     * @param {string} editorWidth string? indicating the editor width
+     * @param {boolean} broadcast (Optional) Flag indicating whether you want to broadcast the editor width change
+     * @throws {SetEditorWidthError} Something went wrong while setting the editor width
+     */
+    setEditorWidth(editorWidth: string, broadcast?: boolean): void;
+    /**
+     * Set the editor width and title and distribute it to all participants. Used by Confluence
+     * @param {Metadata} metadata The metadata you want to update
+     * @throws {ExampleError} Something went wrong while setting the metadata
+     */
+    setMetadata(metadata: Metadata): void;
+    /**
+     * Returns the documents metadata
+     */
+    getMetadata: () => Metadata;
+    /**
+     * Return the ADF version of the current draft document, together with it's title and the current step version.
+     * Used for draft sync, a process running every 5s for the first editor of a document to sync the document to the Confluence back-end.
+     * @throws {GetCurrentStateError} Something went wrong while returning the current state
+     */
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    /**
+     * Return the final acknowledged (by NCS) ADF version of the current draft document, together with it's title and the current step version.
+     * Used when returning the document to Confluence on publish.
+     * @throws {GetFinalAcknowledgedStateError} Something went wrong while returning the acknowledged state
+     */
+    getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
+    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
+    /**
+     * ESS-2916 namespace status event- lock/unlock
+     */
+    private onNamespaceStatusChanged;
+    /**
+     * Used when the provider is disconnected or destroyed to prevent perpetual timers from continuously running
+     */
+    private clearTimers;
+}
+export {};

package/dist/types-ts4.0/socket-io-provider.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from './provider';
+import { Socket } from 'socket.io-client';
+import { Config, ProductInformation, InitAndAuthData, AuthCallback } from './types';
+export declare function createSocketIOSocket(url: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation): Socket;
+export declare function createSocketIOCollabProvider(config: Omit<Config, 'createSocket'>): Provider;

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

@@ -0,0 +1,265 @@
+import type { Step } from 'prosemirror-transform';
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { CollabEventConnectionData, CollabEventInitData, CollabEventRemoteData, CollabEventPresenceData, CollabEventConnectingData, ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import type { AnalyticsWebClient } from '@atlaskit/analytics-listeners';
+import type { Manager } from 'socket.io-client';
+import type { DisconnectReason } from './disconnected-reason-mapper';
+import type { InternalError } from './errors/error-types';
+import type { ProviderError } from './errors/error-types';
+import type { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import { ProviderParticipant } from './participants/participants-helper';
+export interface Storage {
+    get(key: string): Promise<string>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export interface InitialDraft {
+    document: JSONDocNode;
+    version: number;
+    metadata?: Metadata;
+}
+export interface Config {
+    url: string;
+    documentAri: string;
+    lifecycle?: Lifecycle;
+    storage?: Storage;
+    need404?: boolean;
+    createSocket: (path: string, auth?: AuthCallback | InitAndAuthData, productInfo?: ProductInformation) => Socket;
+    /**
+     * @deprecated: Use promise based getAnalyticsWebClient instead
+     */
+    analyticsClient?: AnalyticsWebClient;
+    getAnalyticsWebClient?: Promise<AnalyticsWebClient>;
+    featureFlags?: {
+        [key: string]: boolean;
+    };
+    getUser?(userId: string): Promise<Pick<ProviderParticipant, 'avatar' | 'name' | 'userId'>>;
+    /**
+     * If provided, permissionTokenRefresh is called whenever a new JWT token is required.
+     */
+    permissionTokenRefresh?: () => Promise<string | null>;
+    cacheToken?: boolean;
+    productInfo?: ProductInformation;
+    /**
+     * Throws errors when trying to send data to collab but the client is not offline.
+     * This can lead to potential dataloss and retrying should be considered. Without this flag the provider silently drops the requests.
+     */
+    throwOnNotConnected?: boolean;
+    initialDraft?: InitialDraft;
+}
+export interface InitAndAuthData {
+    initialized: boolean;
+    need404?: boolean;
+    token?: string;
+}
+export declare type AuthCallback = (cb: (data: InitAndAuthData) => void) => void;
+interface SimpleEventEmitter {
+    on(event: string, fn: Function): SimpleEventEmitter;
+}
+export interface Socket extends SimpleEventEmitter {
+    id: string;
+    connect(): Socket;
+    emit(event: string, ...args: any[]): Socket;
+    close(): Socket;
+    io?: Manager;
+}
+export declare type LifecycleEvents = 'save' | 'restore';
+export declare type EventHandler = () => void;
+export interface Lifecycle {
+    on(event: LifecycleEvents, handler: EventHandler): void;
+}
+export declare type CollabConnectedPayload = CollabEventConnectionData;
+export declare type CollabConnectingPayload = CollabEventConnectingData;
+export interface CollabDisconnectedPayload {
+    reason: DisconnectReason;
+    sid: string;
+}
+/**
+ * @deprecated Use ProviderError type instead
+ */
+export declare type CollabErrorPayload = ProviderError;
+export interface CollabInitPayload extends CollabEventInitData {
+    doc: any;
+    version: number;
+    metadata?: Metadata;
+    reserveCursor?: boolean;
+}
+export interface CollabDataPayload extends CollabEventRemoteData {
+    version: number;
+    json: StepJson[];
+    userIds: (number | string)[];
+}
+export declare type CollabTelepointerPayload = CollabEventTelepointerData;
+export declare type CollabPresencePayload = CollabEventPresenceData;
+export declare type CollabMetadataPayload = Metadata;
+export declare type CollabLocalStepsPayload = {
+    steps: readonly Step[];
+};
+export interface CollabEvents {
+    'metadata:changed': CollabMetadataPayload;
+    init: CollabInitPayload;
+    connected: CollabConnectedPayload;
+    disconnected: CollabDisconnectedPayload;
+    data: CollabDataPayload;
+    telepointer: CollabTelepointerPayload;
+    presence: CollabPresencePayload;
+    'local-steps': CollabLocalStepsPayload;
+    error: CollabErrorPayload;
+    entity: any;
+    connecting: CollabConnectingPayload;
+}
+export interface Metadata {
+    [key: string]: string | number | boolean;
+}
+export declare type InitPayload = {
+    doc: any;
+    version: number;
+    userId?: string;
+    metadata?: Metadata;
+};
+/**
+ * @description Incoming payload type from the `broadcast` route in NCS
+ * @param {number} timestamp added in NCS
+ * @param {string} sessionId socket.id from NCS
+ * @param data event specific data from NCS
+ */
+export declare type BroadcastIncomingPayload = {
+    sessionId?: string;
+    timestamp?: number;
+    data: PresencePayload | TelepointerPayload | StepsPayload | any;
+};
+export declare type PresencePayload = {
+    sessionId: string;
+    userId: string | undefined;
+    clientId: number | string;
+    timestamp: number;
+};
+export declare type TelepointerPayload = PresencePayload & {
+    selection: CollabSendableSelection;
+};
+declare type MarkJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+};
+declare type NodeJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+    content: NodeJson[];
+    marks: MarkJson[];
+    text?: string;
+};
+declare type SliceJson = {
+    content: NodeJson[];
+    openStart: number;
+    openEnd: number;
+};
+export declare type StepJson = {
+    stepType?: string;
+    from?: number;
+    to?: number;
+    slice?: SliceJson;
+    clientId: number | string;
+    userId: string;
+    createdAt?: number;
+    structure?: boolean;
+};
+export declare enum AcknowledgementResponseTypes {
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+export declare type AcknowledgementSuccessPayload = {
+    type: AcknowledgementResponseTypes.SUCCESS;
+};
+export declare type AcknowledgementPayload = AcknowledgementSuccessPayload | AcknowledgementErrorPayload;
+export declare type AddStepAcknowledgementSuccessPayload = {
+    type: AcknowledgementResponseTypes.SUCCESS;
+    version: number;
+};
+export declare type AcknowledgementErrorPayload = {
+    type: AcknowledgementResponseTypes.ERROR;
+    error: InternalError;
+};
+export declare type AddStepAcknowledgementPayload = AddStepAcknowledgementSuccessPayload | AcknowledgementErrorPayload;
+export declare type StepsPayload = {
+    version: number;
+    steps: StepJson[];
+};
+export declare type NamespaceStatus = {
+    isLocked: boolean;
+    timestamp: number;
+    waitTimeInMs?: number;
+};
+export declare type ChannelEvent = {
+    connected: {
+        sid: string;
+        initialized: boolean;
+    };
+    init: InitPayload;
+    restore: InitPayload;
+    reconnected: null;
+    'presence:joined': PresencePayload;
+    presence: PresencePayload;
+    'participant:left': PresencePayload;
+    'participant:telepointer': TelepointerPayload;
+    'participant:updated': PresencePayload;
+    'steps:commit': StepsPayload & {
+        userId: string;
+    };
+    'steps:added': StepsPayload;
+    'metadata:changed': Metadata;
+    error: InternalError;
+    disconnect: {
+        reason: string;
+    };
+    status: NamespaceStatus;
+};
+export interface CatchupResponse {
+    doc?: string;
+    version?: number;
+    stepMaps?: any[];
+    metadata?: Metadata;
+}
+export interface CatchupOptions {
+    getCurrentPmVersion: () => number;
+    fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>;
+    filterQueue: (condition: (stepsPayload: StepsPayload) => boolean) => void;
+    getUnconfirmedSteps: () => readonly Step[] | undefined;
+    applyLocalSteps: (steps: Step[]) => void;
+    updateDocument: ({ doc, version, metadata, reserveCursor, }: CollabInitPayload) => void;
+    updateMetadata: (metadata: Metadata | undefined) => void;
+}
+export declare type ProductInformation = {
+    product: string;
+    subProduct?: string;
+};
+export interface CollabEventTelepointerData {
+    type: 'telepointer';
+    selection: CollabSendableSelection;
+    sessionId: string;
+}
+export interface CollabSendableSelection {
+    type: 'textSelection' | 'nodeSelection';
+    anchor?: number | string;
+    head?: number | string;
+}
+export interface CollabEditProvider<Events extends CollabEvents = CollabEvents> {
+    initialize(getState: () => any, createStep: (json: object) => Step): this;
+    setup(props: {
+        getState: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+    }): this;
+    send(tr: Transaction, oldState: EditorState, newState: EditorState): void;
+    on(evt: keyof Events, handler: (...args: any) => void): this;
+    off(evt: keyof Events, handler: (...args: any) => void): this;
+    unsubscribeAll(evt: keyof Events): this;
+    sendMessage<K extends keyof Events>(data: {
+        type: K;
+    } & Events[K]): void;
+    getFinalAcknowledgedState(): Promise<ResolvedEditorState>;
+}
+export {};

package/dist/types-ts4.0/version-wrapper.d.ts

@@ -0,0 +1,3 @@
+export declare const name: string;
+export declare const version: string;
+export declare const nextMajorVersion: () => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/collab-provider",
-  "version": "8.8.0",
+  "version": "8.8.1",
   "description": "A provider for collaborative editing.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"