@atlaskit/collab-provider 8.3.0 → 8.5.0

package/dist/esm/types.js

@@ -1,3 +1,7 @@
+/**
+ * @deprecated Use ProviderError type instead
+ */
+
 // Channel
 
 export var AcknowledgementResponseTypes;

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/collab-provider";
-export var version = "8.3.0";
+export var version = "8.5.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": "8.3.0",
+	"version": "8.5.0",
 	"sideEffects": false
 }

package/dist/types/analytics/{index.d.ts → analytics-helper.d.ts}

@@ -2,8 +2,10 @@ import type { AnalyticsWebClient } from '@atlaskit/analytics-listeners';
 import type { ActionAnalyticsEvent, EVENT_STATUS } from '../helpers/const';
 export default class AnalyticsHelper {
     analyticsClient: AnalyticsWebClient | undefined;
+    getAnalyticsClient: Promise<AnalyticsWebClient> | undefined;
     documentAri: string;
-    constructor(documentAri: string, analyticsClient?: AnalyticsWebClient);
+    constructor(documentAri: string, analyticsClient?: AnalyticsWebClient, getAnalyticsClient?: Promise<AnalyticsWebClient>);
     sendErrorEvent(error: unknown, errorMessage: string): void;
     sendActionEvent(action: ActionAnalyticsEvent['eventAction'], status: EVENT_STATUS, attributes?: Omit<ActionAnalyticsEvent['attributes'], 'documentAri' | 'eventStatus'>): void;
+    private sendEvent;
 }

package/dist/types/analytics/performance.d.ts

@@ -1,10 +1,13 @@
-import AnalyticsHelper from '.';
+import AnalyticsHelper from './analytics-helper';
 export declare enum MEASURE_NAME {
     SOCKET_CONNECT = "socketConnect",
     DOCUMENT_INIT = "documentInit",
     COMMIT_UNCONFIRMED_STEPS = "commitUnconfirmedSteps",
-    PUBLISH_PAGE = "publishPage"
+    PUBLISH_PAGE = "publishPage",
+    GET_CURRENT_STATE = "getCurrentState"
 }
+export declare const isPerformanceAPIAvailable: () => boolean;
+export declare const measureMap: Map<string, number>;
 export declare function startMeasure(measureName: MEASURE_NAME, analyticsHelper: AnalyticsHelper | undefined): void;
 export declare function stopMeasure(measureName: MEASURE_NAME, analyticsHelper: AnalyticsHelper | undefined, onMeasureComplete?: (duration: number, startTime: number) => void): {
     duration: number;

package/dist/types/analytics/ufo.d.ts

@@ -1,3 +1,3 @@
 import { UFOExperience } from '@atlaskit/ufo';
-import AnalyticsHelper from '.';
+import AnalyticsHelper from './analytics-helper';
 export declare const createDocInitExp: (analyticsHelper: AnalyticsHelper | undefined) => UFOExperience | undefined;

package/dist/types/channel.d.ts

@@ -1,7 +1,7 @@
 import { Emitter } from './emitter';
 import type { Config, ChannelEvent, CatchupResponse, Metadata } from './types';
 import type { Socket } from 'socket.io-client';
-import AnalyticsHelper from './analytics';
+import AnalyticsHelper from './analytics/analytics-helper';
 export declare class Channel extends Emitter<ChannelEvent> {
     private connected;
     private config;
@@ -10,25 +10,37 @@ export declare class Channel extends Emitter<ChannelEvent> {
     private initialized;
     private analyticsHelper?;
     private initExperience?;
+    private token?;
     private network;
     constructor(config: Config, analyticsHelper: AnalyticsHelper);
     getInitialized: () => boolean;
     getConnected: () => boolean;
     getSocket: () => Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap> | null;
+    getToken: () => string | undefined;
+    private setToken;
+    private unsetToken;
     /**
      * Connect to collab service using websockets
      */
     connect(): void;
+    private handlePermissionInvalidateToken;
     private onConnectError;
     private onReconnectError;
     private onConnect;
     private onReceiveData;
-    fetchCatchup(fromVersion: number): Promise<CatchupResponse>;
+    fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>;
     /**
-     * Send message to service. Timestamp will be added server side.
+     * Send message to the back-end service over the channel. Timestamp will be added server side.
+     * @throws {NotInitializedError} Channel not initialized
+     * @throws {NotConnectedError} Channel not connected
      */
-    broadcast<K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function): void;
-    sendMetadata(metadata: Metadata): void;
+    broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], "timestamp">, callback?: Function | undefined) => void;
+    /**
+     * Send metadata to to the back-end service over the channel
+     * @throws {NotInitializedError} Channel not initialized
+     * @throws {NotConnectedError} Channel not connected
+     */
+    sendMetadata: (metadata: Metadata) => void;
     sendPresenceJoined(): void;
     onOnlineHandler: () => void;
     disconnect(): void;

package/dist/types/document/document-service.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="lodash" />
+import AnalyticsHelper from '../analytics/analytics-helper';
+import { CatchupResponse, ChannelEvent, CollabEvents, CollabInitPayload, Metadata, StepsPayload } from '../types';
+import type { Step as ProseMirrorStep } from 'prosemirror-transform';
+import { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+import type { EditorState, Transaction } from 'prosemirror-state';
+import { ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import { ParticipantsService } from '../participants/participants-service';
+import type { InternalError } from '../errors/error-types';
+export declare class DocumentService {
+    private participantsService;
+    private analyticsHelper;
+    private fetchCatchup;
+    private providerEmitCallback;
+    private broadcastMetadata;
+    private broadcast;
+    private getUserId;
+    private onErrorHandled;
+    private getState;
+    private onSyncUpError?;
+    private stepQueue;
+    private stepRejectCounter;
+    private metadata;
+    private clientId?;
+    /**
+     *
+     * @param participantsService - The participants service, used when users are detected active when making changes to the document
+     * and to emit their telepointers from steps they add
+     * @param analyticsHelper - Helper for analytics events
+     * @param fetchCatchup - Function to fetch "catchup" data, data required to rebase current steps to the latest version.
+     * @param providerEmitCallback - Callback for emitting events to listeners on the provider
+     * @param broadcastMetadata - Callback for broadcasting metadata changes to other clients
+     * @param broadcast - Callback for broadcasting events to other clients
+     * @param getUserId - Callback to fetch the current user's ID
+     * @param onErrorHandled - Callback to handle
+     */
+    constructor(participantsService: ParticipantsService, analyticsHelper: AnalyticsHelper | undefined, fetchCatchup: (fromVersion: number) => Promise<CatchupResponse>, providerEmitCallback: (evt: keyof CollabEvents, data: any) => void, broadcastMetadata: (metadata: Metadata) => void, broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void, getUserId: () => string | undefined, onErrorHandled: (error: InternalError) => void);
+    /**
+     * Called when a metadata is changed externally from other clients/backend.
+     */
+    onMetadataChanged: (metadata: Metadata) => void;
+    getMetaData: () => Metadata;
+    setTitle(title: string, broadcast?: boolean): void;
+    setEditorWidth(editorWidth: string, broadcast?: boolean): void;
+    /**
+     * Updates the local metadata and broadcasts the metadata to other clients/backend.
+     * @param metadata
+     */
+    setMetadata(metadata: Metadata): void;
+    /**
+     * To prevent calling catchup to often, use lodash throttle to reduce the frequency
+     */
+    throttledCatchup: import("lodash").DebouncedFunc<() => Promise<void>>;
+    /**
+     * Called when:
+     *   * session established(offline -> online)
+     *   * try to accept steps but version is behind.
+     */
+    private catchup;
+    getCurrentPmVersion: () => number;
+    private processQueue;
+    getCurrentState: () => Promise<ResolvedEditorState>;
+    private processSteps;
+    getUnconfirmedStepsOrigins: () => readonly Transaction<any>[] | undefined;
+    getUnconfirmedSteps: () => readonly ProseMirrorStep[] | undefined;
+    private applyLocalSteps;
+    /**
+     * Emits the initialisation data for a document
+     * @param doc
+     * @param version
+     * @param metadata
+     * @param reserveCursor
+     */
+    updateDocumentWithMetadata: ({ doc, version, metadata, reserveCursor, }: CollabInitPayload) => void;
+    /**
+     * Called when we receive steps from the service
+     */
+    onStepsAdded: (data: StepsPayload) => void;
+    onRestore: ({ doc, version, metadata }: CollabInitPayload) => void;
+    getFinalAcknowledgedState: () => Promise<ResolvedEditorState>;
+    /**
+     * Commit the unconfirmed local steps to the back-end service
+     * @throws {Error} Couldn't sync the steps after retrying 30 times
+     */
+    commitUnconfirmedSteps: () => Promise<void>;
+    setup({ getState, onSyncUpError, clientId, }: {
+        getState: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+        clientId: number | string | undefined;
+    }): this;
+    /**
+     * We can use this function to throttle/delay
+     * Any send steps operation
+     *
+     * The getState function will return the current EditorState
+     * from the EditorView.
+     */
+    sendStepsFromCurrentState(): void;
+    onStepRejectedError: () => void;
+    /**
+     * Send steps from transaction to other participants
+     * It needs the superfluous arguments because we keep the interface of the send API the same as the Synchrony plugin
+     */
+    send(_tr: Transaction | null, _oldState: EditorState | null, newState: EditorState): void;
+}

package/dist/types/document/step-queue-state.d.ts

@@ -0,0 +1,16 @@
+import { StepsPayload } from '../types';
+export declare class StepQueueState {
+    private queuePaused;
+    private queue;
+    queueSteps(data: StepsPayload): void;
+    getQueue: () => StepsPayload[];
+    filterQueue: (condition: (stepsPayload: StepsPayload) => boolean) => void;
+    /**
+     * Get whether the document service has stopped processing new steps whilst it carries out processes such as catchup.
+     * Exposed for testing
+     */
+    isPaused: () => boolean;
+    pauseQueue: () => void;
+    resumeQueue: () => void;
+    shift: () => StepsPayload | undefined;
+}

package/dist/types/errors/error-code-mapper.d.ts

@@ -0,0 +1,2 @@
+import { InternalError, ProviderError } from './error-types';
+export declare const errorCodeMapper: (error: InternalError) => ProviderError | undefined;

package/dist/types/errors/error-types.d.ts

@@ -0,0 +1,443 @@
+export declare enum INTERNAL_ERROR_CODE {
+    TOKEN_PERMISSION_ERROR = "TOKEN_PERMISSION_ERROR",
+    RECONNECTION_NETWORK_ISSUE = "RECONNECTION_NETWORK_ISSUE",
+    CONNECTION_ERROR = "CONNECTION_ERROR",
+    RECONNECTION_ERROR = "RECONNECTION_ERROR",
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    CATCHUP_FAILED = "CATCHUP_FAILED",
+    DOCUMENT_RESTORE_ERROR = "DOCUMENT_RESTORE_ERROR",
+    ADD_STEPS_ERROR = "ADD_STEPS_ERROR"
+}
+export declare enum NCS_ERROR_CODE {
+    HEAD_VERSION_UPDATE_FAILED = "HEAD_VERSION_UPDATE_FAILED",
+    VERSION_NUMBER_ALREADY_EXISTS = "VERSION_NUMBER_ALREADY_EXISTS",
+    INSUFFICIENT_EDITING_PERMISSION = "INSUFFICIENT_EDITING_PERMISSION",
+    FORBIDDEN_USER_TOKEN = "FORBIDDEN_USER_TOKEN",
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    INIT_DATA_LOAD_FAILED = "INIT_DATA_LOAD_FAILED",
+    ERROR_MAPPING_ERROR = "ERROR_MAPPING_ERROR",
+    NAMESPACE_INVALID = "NAMESPACE_INVALID",
+    NAMESPACE_NOT_FOUND = "NAMESPACE_NOT_FOUND",
+    TENANT_INSTANCE_MAINTENANCE = "TENANT_INSTANCE_MAINTENANCE",
+    LOCKED_DOCUMENT = "LOCKED_DOCUMENT",
+    EMPTY_BROADCAST = "EMPTY_BROADCAST",
+    DYNAMO_ERROR = "DYNAMO_ERROR",
+    INVALID_ACTIVATION_ID = "INVALID_ACTIVATION_ID",
+    INVALID_DOCUMENT_ARI = "INVALID_DOCUMENT_ARI",
+    INVALID_CLOUD_ID = "INVALID_CLOUD_ID"
+}
+declare type HeadVersionUpdateFailedError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.HEAD_VERSION_UPDATE_FAILED;
+        meta: {
+            currentVersion: any;
+            incomingVersion: number;
+        };
+        status: number;
+    };
+};
+declare type VersionAlreadyPresentInDynamoError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.VERSION_NUMBER_ALREADY_EXISTS;
+        meta: string;
+        status: number;
+    };
+};
+declare type InsufficientEditingPermissionError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INSUFFICIENT_EDITING_PERMISSION;
+        meta: {
+            description: string;
+            reason?: string;
+        };
+        status: number;
+    };
+};
+declare type ForbiddenUserTokenError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.FORBIDDEN_USER_TOKEN;
+        meta: string;
+        status: number;
+    };
+};
+declare type NCSDocumentNotFoundError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.DOCUMENT_NOT_FOUND;
+        status: number;
+    };
+};
+declare type FailedToLoadInitDataError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INIT_DATA_LOAD_FAILED;
+        status: number;
+    };
+};
+declare type ErrorMappingError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.ERROR_MAPPING_ERROR;
+        status: number;
+    };
+};
+declare type InvalidNamespaceDefinedError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.NAMESPACE_INVALID;
+        meta: string;
+        status: number;
+    };
+};
+declare type SocketNamespaceNotFoundError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.NAMESPACE_NOT_FOUND;
+        meta: string;
+        status: number;
+    };
+};
+declare type TenantInstanceMaintenanceError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.TENANT_INSTANCE_MAINTENANCE;
+        meta: {
+            description: string;
+            reason: string;
+        };
+        status: number;
+    };
+};
+declare type NamespaceLockedError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.LOCKED_DOCUMENT;
+        meta: string;
+        status: number;
+    };
+};
+declare type EmptyBroadcastError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.EMPTY_BROADCAST;
+        meta: string;
+        status: number;
+    };
+};
+declare type DynamoError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.DYNAMO_ERROR;
+        meta: string;
+        status: number;
+    };
+};
+declare type InvalidActivationIdError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INVALID_ACTIVATION_ID;
+        meta: string;
+        status: number;
+    };
+};
+declare type InvalidDocumentAriError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INVALID_DOCUMENT_ARI;
+        meta: string;
+        status: number;
+    };
+};
+declare type InvalidCloudIdError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INVALID_CLOUD_ID;
+        meta: string;
+        status: number;
+    };
+};
+declare type NCSErrors = HeadVersionUpdateFailedError | VersionAlreadyPresentInDynamoError | InsufficientEditingPermissionError | ForbiddenUserTokenError | NCSDocumentNotFoundError | FailedToLoadInitDataError | ErrorMappingError | InvalidNamespaceDefinedError | SocketNamespaceNotFoundError | TenantInstanceMaintenanceError | NamespaceLockedError | EmptyBroadcastError | DynamoError | InvalidActivationIdError | InvalidDocumentAriError | InvalidCloudIdError;
+declare type DocumentRecoveryError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.DOCUMENT_RESTORE_ERROR;
+        status: number;
+    };
+};
+declare type AddStepsError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.ADD_STEPS_ERROR;
+        status: number;
+    };
+};
+export declare type CatchUpFailedError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.CATCHUP_FAILED;
+        status: number;
+    };
+};
+export declare type TokenPermissionError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.TOKEN_PERMISSION_ERROR;
+        status: number;
+        meta: {
+            originalError?: unknown;
+            reason?: string;
+        };
+    };
+};
+export declare type ReconnectionError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.RECONNECTION_ERROR;
+        status: number;
+    };
+};
+export declare type ConnectionError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.CONNECTION_ERROR;
+    };
+};
+export declare type ReconnectionNetworkError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.RECONNECTION_NETWORK_ISSUE;
+    };
+};
+export declare type DocumentNotFoundError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.DOCUMENT_NOT_FOUND;
+        status: number;
+    };
+};
+/**
+ * A union of all possible internal errors, that are mapped to another error if being emitted to the editor.
+ */
+export declare type InternalError = NCSErrors | DocumentRecoveryError | AddStepsError | CatchUpFailedError | TokenPermissionError | ReconnectionError | ConnectionError | ReconnectionNetworkError | DocumentNotFoundError;
+export declare enum PROVIDER_ERROR_CODE {
+    NO_PERMISSION_ERROR = "NO_PERMISSION_ERROR",
+    INVALID_USER_TOKEN = "INVALID_USER_TOKEN",
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    LOCKED = "LOCKED",
+    FAIL_TO_SAVE = "FAIL_TO_SAVE",
+    DOCUMENT_RESTORE_ERROR = "DOCUMENT_RESTORE_ERROR",
+    INITIALISATION_ERROR = "INITIALISATION_ERROR",
+    NETWORK_ISSUE = "NETWORK_ISSUE",
+    INVALID_PROVIDER_CONFIGURATION = "INVALID_PROVIDER_CONFIGURATION",
+    INTERNAL_SERVICE_ERROR = "INTERNAL_SERVICE_ERROR"
+}
+/**
+ * This occurs when the provided user token is considered invalid for the given document ARI.
+ * It happens during initialisation of the provider.
+ * It could mean the document has been deleted (hence not found).
+ * @message Message returned to editor, i.e User does not have permissions to access this document or document is not found
+ * @recoverable It is recoverable, as we will try to refresh the token.
+ */
+declare type InsufficientEditingPermission = {
+    code: PROVIDER_ERROR_CODE.NO_PERMISSION_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason?: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Similiar to InsufficientEditingPermission, but the user token is invalid because it has expired or been revoked.
+ * It may also be an invalid token format.
+ * This error is given to the provider by NCS.
+ * @message Message returned to editor, i.e. The user token was invalid
+ * @recoverable It is recoverable, as we will try to refresh the token.
+ */
+declare type InvalidUserToken = {
+    code: PROVIDER_ERROR_CODE.INVALID_USER_TOKEN;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Document not found error, thrown when the provider is unable to find a document with the given ARI and user token.
+ * It occurs during fetchCatchup, a function that fetches the latest document state during catchup.
+ * We need to recieve a 404 from the document service to throw this error.
+ * @message Message returned to editor, i.e. The requested document is not found
+ * @recoverable It is recoverable, as the provider can try again later.
+ */
+declare type DocumentNotFound = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_NOT_FOUND;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the document is locked by another user.
+ * The error is passed to us by NCS.
+ * @message Message returned to editor, i.e. The document is currently not available, please try again later
+ * @recoverable It is recoverable, as the provider can try again later.
+ */
+declare type Locked = {
+    code: PROVIDER_ERROR_CODE.LOCKED;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+/**
+ * This error is thrown when the provider is unable to save the document.
+ * This can happen when the connection to dynamoDB is lost, or when we do not have sufficient permissions (DYNAMO ERROR).
+ * This error is given to us by NCS.
+ * @message Message returned to editor, i.e. Collab service is not able to save changes
+ * @recoverable It is not recoverable, as we don't want the user to continue editing a document that is not being saved.
+ */
+declare type FailToSave = {
+    code: PROVIDER_ERROR_CODE.FAIL_TO_SAVE;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider is unable to restore the document.
+ * It occurs during onRestore, a function that restores the document to a previous version and reapplies unconfirmed steps.
+ * onRestore is called when page recovery has emitted an 'init' event on a page client is currently connected to.
+ * It could mean we failed to update the page metadata, or we failed to reapply unconfirmed steps.
+ * @message Message returned to editor, i.e. Collab service unable to restore document
+ * @recoverable It is not recoverable, as the provider has no further options after this.
+ * The user will need to refresh the page to try again.
+ */
+declare type DocumentNotRestore = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_RESTORE_ERROR;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * The initial document couldn't be loaded from the collab service.
+ * This error is given to us by NCS.
+ * It could indicate either a network issue, or an internal service error in NCS.
+ * @message Message returned to editor, i.e. The initial document couldn't be loaded from the collab service
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ * The user will need to refresh the page to try again.
+ */
+declare type InitialisationError = {
+    code: PROVIDER_ERROR_CODE.INITIALISATION_ERROR;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Couldn't reconnect to the collab service (NCS) due to network issues.
+ * NCS could be down, or the user could be offline. It's also possible the url is incorrect, or the user is behind a proxy blocking the connection.
+ * Fired upon a reconnection attempt error (from Socket.IO Manager)
+ * @message Message returned to editor, i.e. Couldn't reconnect to the collab service due to network issues
+ * @recoverable It is recoverable, as the provider will try to reconnect.
+ */
+declare type NetworkIssue = {
+    code: PROVIDER_ERROR_CODE.NETWORK_ISSUE;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider has an invalid configuration.
+ * It could happen due to these errors from NCS:
+ *  NAMESPACE_INVALID
+    INVALID_ACTIVATION_ID
+    INVALID_DOCUMENT_ARI
+    INVALID_CLOUD_ID
+ * @message Message returned to editor, i.e. Invalid provider configuration
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ * The service using the provider will need to fix the configuration.
+ */
+declare type InvalidProviderConfiguration = {
+    code: PROVIDER_ERROR_CODE.INVALID_PROVIDER_CONFIGURATION;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider encounters an internal service error, not otherwise accounted for.
+ * @message Message returned to editor, i.e. Collab Provider experienced an unrecoverable error
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ */
+declare type InternalServiceError = {
+    code: PROVIDER_ERROR_CODE.INTERNAL_SERVICE_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * A union of all possible provider errors that can be emitted back to the editor.
+ */
+export declare type ProviderError = InsufficientEditingPermission | InvalidUserToken | DocumentNotFound | Locked | FailToSave | DocumentNotRestore | InitialisationError | NetworkIssue | InvalidProviderConfiguration | InternalServiceError;
+declare class CustomError extends Error {
+    constructor(message: string, error?: unknown);
+    toJSON(): {
+        name: string;
+        message: string;
+    };
+}
+export declare class NotConnectedError extends CustomError {
+    name: string;
+}
+export declare class NotInitializedError extends CustomError {
+    name: string;
+}
+export declare class ProviderInitialisationError extends CustomError {
+    name: string;
+}
+export declare class SendTransactionError extends CustomError {
+    name: string;
+}
+export declare class DestroyError extends CustomError {
+    name: string;
+}
+export declare class SetTitleError extends CustomError {
+    name: string;
+}
+export declare class SetEditorWidthError extends CustomError {
+    name: string;
+}
+export declare class SetMetadataError extends CustomError {
+    name: string;
+}
+export declare class GetCurrentStateError extends CustomError {
+    name: string;
+}
+export declare class GetFinalAcknowledgedStateError extends CustomError {
+    name: string;
+}
+export {};