@atlaskit/collab-provider 8.4.0 → 8.5.0

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

@@ -1,8 +1,443 @@
-export declare class NotConnectedError extends Error {
+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;
-    constructor(message: string);
 }
-export declare class NotInitializedError extends Error {
+export declare class GetFinalAcknowledgedStateError extends CustomError {
     name: string;
-    constructor(message: string);
 }
+export {};

package/dist/types/helpers/const.d.ts

@@ -1,4 +1,4 @@
-import type { CollabErrorPayload } from '../types';
+import type { ProviderError } from '../errors/error-types';
 export declare enum EVENT_ACTION {
     CONNECTION = "connection",
     CATCHUP = "catchup",
@@ -27,7 +27,7 @@ export declare type ErrorAnalyticsEvent = {
         errorMessage: string;
         errorName?: string;
         documentAri?: string;
-        mappedError?: CollabErrorPayload;
+        mappedError?: ProviderError;
     };
     nonPrivacySafeAttributes: {
         error: unknown;

package/dist/types/helpers/utils.d.ts

@@ -1,11 +1,5 @@
 import type { ProductInformation } from '../types';
 export declare const createLogger: (prefix: string, color?: string) => (msg: string, data?: any) => void;
-export declare const getParticipant: (userId: string) => {
-    userId: string;
-    name: string;
-    avatar: string;
-    email: string;
-};
 export declare function sleep(ms: number): Promise<unknown>;
 export declare const getProduct: (productInfo?: ProductInformation | undefined) => string;
 export declare const getSubProduct: (productInfo?: ProductInformation | undefined) => string;

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export { Provider } from './provider';
-export type { CollabConnectedPayload, CollabDisconnectedPayload, CollabErrorPayload, CollabInitPayload, CollabDataPayload, CollabTelepointerPayload, CollabPresencePayload, CollabMetadataPayload, CollabLocalStepsPayload, CollabEvents, Socket, } from './types';
+export type { CollabConnectedPayload, CollabDisconnectedPayload, CollabErrorPayload, CollabInitPayload, CollabDataPayload, CollabTelepointerPayload, CollabPresencePayload, CollabMetadataPayload, CollabLocalStepsPayload, CollabEvents, CollabSendableSelection, CollabEditProvider, Socket, } from './types';
+export type { PROVIDER_ERROR_CODE, ProviderError } from './errors/error-types';

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

@@ -0,0 +1,15 @@
+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 const createParticipantFromPayload: (payload: PresencePayload & {
+    userId: string;
+}, getUser: ((userId: string) => Promise<Pick<CollabParticipant, "avatar" | "email" | "name"> & {
+    userId: string;
+}>) | undefined) => Promise<ProviderParticipant>;

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

@@ -0,0 +1,70 @@
+import type { CollabEventPresenceData, CollabParticipant, CollabEventDisconnectedData } from '@atlaskit/editor-common/collab';
+import AnalyticsHelper from '../analytics/analytics-helper';
+import type { CollabEventTelepointerData, PresencePayload, StepJson, TelepointerPayload } from '../types';
+import { 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: ((userId: string) => Promise<Pick<CollabParticipant, "avatar" | "email" | "name"> & {
+        userId: string;
+    }>) | undefined, 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: ((userId: string) => Promise<Pick<CollabParticipant, "avatar" | "email" | "name"> & {
+        userId: string;
+    }>) | undefined, 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;
+}

package/dist/types/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/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/provider/commit-step.d.ts

@@ -1,14 +1,14 @@
-import { ErrorPayload, StepsPayload } from '../types';
+import { ChannelEvent, StepsPayload } from '../types';
 import type { Step as ProseMirrorStep } from 'prosemirror-transform';
-import type { Channel } from '../channel';
-import AnalyticsHelper from '../analytics';
-export declare const commitStep: ({ channel, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, }: {
-    channel: Channel;
+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: ErrorPayload) => void;
+    onErrorHandled: (error: InternalError) => void;
     analyticsHelper?: AnalyticsHelper | undefined;
 }) => void;