@univerjs-pro/collaboration-client 0.4.2 → 0.5.0-nightly.202411091605

package/lib/types/index.d.ts

@@ -1,34 +1,890 @@
-export { 
-/** @deprecated Will be removed in the 0.2.19 release */
-COLLAB_SUBMIT_CHANGESET_URL_KEY, 
-/** @deprecated Will be removed in the 0.2.19 release */
-COLLAB_WEB_SOCKET_URL_KEY, HEARTBEAT_INTERVAL_KEY, HEARTBEAT_TIMEOUT_KEY, LOCAL_CACHE_INTERVAL_KEY, LOGIN_URL_KEY, RETRY_CONNECTING_MAX_COUNT_KEY, 
-/** @deprecated Will be removed in the 0.2.19 release */
-SEND_CHANGESET_TIMEOUT_KEY, 
-/** @deprecated Will be removed in the 0.2.19 release */
-SNAPSHOT_SERVER_URL_KEY, 
-/** @deprecated Will be removed in the 0.2.19 release */
-SNAPSHOT_URL_KEY, } from './config/config';
-export { CollaborationController } from './controllers/collaboration/collaboration.controller';
-export { CollaborationEntity, DocCollaborationEntity, SheetCollaborationEntity } from './controllers/collaboration/collaboration-entity';
-export { CollaborationStatus } from './controllers/collaboration/collaboration-state';
-export { UniverCollaborationClientPlugin } from './plugin';
-export { CollaborationSessionService } from './services/collaboration-session/collaboration-session.service';
-export { CollaborationSession, SessionStatus } from './services/collaboration-session/collaboration-session';
-export type { ICollaborationSocket } from './services/socket/collaboration-socket.service';
-export { CollaborationSocketService, ICollaborationSocketService, } from './services/socket/collaboration-socket.service';
-export { LocalCacheService } from './services/local-cache/local-cache.service';
-export { IURLService } from './services/url/url.service';
-export { WebURLService } from './services/url/web-url.service';
-export { DataLoaderController } from './controllers/data-loader/data-loader.controller';
-export { DesktopCollaborationStatusDisplayController } from './controllers/collab-status/collab-status.controller';
-export { AuthzIoHttpService } from './services/auth-server/authz-io-http.service';
-/** @deprecated Will be removed in the 0.2.19 release */
-export { AUTHZ_URL_KEY } from './services/auth-server/authz-io-http.service';
-export { deserializeToCombResponse, serializeCombRequest } from './services/socket/serialize';
-export { CollaborationStatusDisplay } from './views/components/CollabStatus';
-export { SnapshotServerOverHTTPService } from './services/snapshot-server/snapshot-server.service';
-export { CommentService } from './services/comment/comment.service';
-export { type ISheetCollabCursorShapeProps, SheetCollabCursorShape } from './views/shapes/sheet-collab-cursor.shape';
-export { ImageIoService } from './services/image-remote/image-io.service';
-export { MemberService } from './services/member/member.service';
+import { BehaviorSubject } from 'rxjs';
+import { CompressMutationService } from '@univerjs-pro/collaboration';
+import { Ctor } from '@univerjs/core';
+import { DependencyOverride } from '@univerjs/core';
+import { Disposable as Disposable_2 } from '@univerjs/core';
+import { DocStateChangeManagerService } from '@univerjs/docs-ui';
+import { HTTPService } from '@univerjs/network';
+import { IAcknowledgedChangeset } from '@univerjs-pro/collaboration';
+import { IActionInfo } from '@univerjs/protocol';
+import { IAllowedRequest } from '@univerjs/protocol';
+import { IAuthzIoService } from '@univerjs/core';
+import { IBatchAllowedResponse } from '@univerjs/protocol';
+import { IBeforeCloseService } from '@univerjs/ui';
+import { IChangeset } from '@univerjs-pro/collaboration';
+import { IChangeset as IChangeset_2 } from '@univerjs/protocol';
+import { ICollaborationEvent } from '@univerjs-pro/collaboration';
+import { ICollaborator } from '@univerjs/protocol';
+import { ICombRequestEvent } from '@univerjs-pro/collaboration';
+import { ICombResponseEvent } from '@univerjs-pro/collaboration';
+import { ICommandService } from '@univerjs/core';
+import { ICommentUpdate } from '@univerjs/protocol';
+import { IConfigService } from '@univerjs/core';
+import { ICopyFileMetaResponse } from '@univerjs/protocol';
+import { ICreateCollaboratorRequest } from '@univerjs/protocol';
+import { ICreateRequest } from '@univerjs/protocol';
+import { IDeleteCollaboratorRequest } from '@univerjs/protocol';
+import { IdentifierDecorator } from '@wendellhu/redi';
+import { IDisposable } from '@univerjs/core';
+import { IFetchingMissEvent } from '@univerjs-pro/collaboration';
+import { IFetchMissingChangesetsRequest } from '@univerjs/protocol';
+import { IFetchMissingChangesetsResponse } from '@univerjs/protocol';
+import { IGetDeserializedSheetBlockResponse } from '@univerjs/protocol';
+import { IGetLatestCsReqIdBySidResponse } from '@univerjs/protocol';
+import { IGetResourcesRequest } from '@univerjs/protocol';
+import { IGetResourcesResponse } from '@univerjs/protocol';
+import { IGetSheetBlockRequest } from '@univerjs/protocol';
+import { IGetSheetBlockResponse } from '@univerjs/protocol';
+import { IGetUnitOnRevRequest } from '@univerjs/protocol';
+import { IGetUnitOnRevResponse } from '@univerjs/protocol';
+import { IImageIoService } from '@univerjs/drawing';
+import { IImageIoServiceParam } from '@univerjs/drawing';
+import { IListCollaboratorRequest } from '@univerjs/protocol';
+import { IListPermPointRequest } from '@univerjs/protocol';
+import { IListPermPointResponse } from '@univerjs/protocol';
+import { IListRolesRequest } from '@univerjs/protocol';
+import { ILocalStorageService } from '@univerjs/core';
+import { ILogContext } from '@univerjs-pro/collaboration';
+import { ILogService } from '@univerjs/core';
+import { ImageSourceType } from '@univerjs/drawing';
+import { IMember } from '@univerjs/protocol';
+import { IMessageService } from '@univerjs/ui';
+import { IMouseEvent } from '@univerjs/engine-render';
+import { IMutationInfo } from '@univerjs/core';
+import { Injector } from '@univerjs/core';
+import { IPermissionService } from '@univerjs/core';
+import { IPointerEvent } from '@univerjs/engine-render';
+import { IPutCollaboratorsRequest } from '@univerjs/protocol';
+import { IRange } from '@univerjs/core';
+import { IRemoteInstanceService } from '@univerjs/rpc';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { ISaveChangesetResponse } from '@univerjs/protocol';
+import { ISaveSheetBlockResponse } from '@univerjs/protocol';
+import { ISaveSnapshotResponse } from '@univerjs/protocol';
+import { IShapeProps } from '@univerjs/engine-render';
+import { ISnapshotServerService } from '@univerjs-pro/collaboration';
+import { ISocket } from '@univerjs/network';
+import { ISubmitChangesetEvent } from '@univerjs-pro/collaboration';
+import { ITelemetryService } from '@univerjs/telemetry';
+import { ITextRangeWithStyle } from '@univerjs/engine-render';
+import { ITransformService } from '@univerjs-pro/collaboration';
+import { IUIPartsService } from '@univerjs/ui';
+import { IUndoRedoService } from '@univerjs/core';
+import { IUnitRoleKV } from '@univerjs/protocol';
+import { IUniverInstanceService } from '@univerjs/core';
+import { IUpdateCollaboratorRequest } from '@univerjs/protocol';
+import { IUpdateCursor } from '@univerjs/protocol';
+import { IUpdatePermPointRequest } from '@univerjs/protocol';
+import { LocaleService } from '@univerjs/core';
+import { Nullable } from '@univerjs/core';
+import { Observable } from 'rxjs';
+import { Plugin as Plugin_2 } from '@univerjs/core';
+import { RevisionService } from '@univerjs-pro/collaboration';
+import { RxDisposable } from '@univerjs/core';
+import { Shape } from '@univerjs/engine-render';
+import { SnapshotService } from '@univerjs-pro/collaboration';
+import { UnitAction } from '@univerjs/protocol';
+import { UniverType } from '@univerjs/protocol';
+import { UserManagerService } from '@univerjs/core';
+import { WebSocketService } from '@univerjs/network';
+
+/** @deprecated Will be removed in the 0.2.19 release */
+export declare const AUTHZ_URL_KEY = "AUTHZ_URL_KEY";
+
+export declare class AuthzIoHttpService extends Disposable_2 implements IAuthzIoService {
+    private _HTTPService;
+    private _configService;
+    constructor(_HTTPService: HTTPService, _configService: IConfigService);
+    private _initMergeInterceptor;
+    private _getAPIPrefixPath;
+    create(config: ICreateRequest): Promise<string>;
+    list(config: IListPermPointRequest): Promise<IListPermPointResponse['objects']>;
+    update(config: IUpdatePermPointRequest): Promise<void>;
+    allowed(config: IAllowedRequest): Promise<IActionInfo[]>;
+    batchAllowed(config: IAllowedRequest[]): Promise<IBatchAllowedResponse['objectActions']>;
+    listRoles(config: IListRolesRequest): Promise<{
+        roles: IUnitRoleKV[];
+        actions: UnitAction[];
+    }>;
+    deleteCollaborator(config: IDeleteCollaboratorRequest): Promise<void>;
+    updateCollaborator(config: IUpdateCollaboratorRequest): Promise<void>;
+    createCollaborator(config: ICreateCollaboratorRequest): Promise<void>;
+    listCollaborators(config: IListCollaboratorRequest): Promise<ICollaborator[]>;
+    putCollaborators(config: IPutCollaboratorsRequest): Promise<void>;
+}
+
+/** @deprecated Will be removed in the 0.2.19 release */
+export declare const COLLAB_SUBMIT_CHANGESET_URL_KEY = "COLLAB_SUBMIT_CHANGESET_URL";
+
+/** @deprecated Will be removed in the 0.2.19 release */
+export declare const COLLAB_WEB_SOCKET_URL_KEY = "COLLAB_WEB_SOCKET_URL";
+
+export declare class CollaborationController extends RxDisposable {
+    private readonly _injector;
+    private readonly _collabSessionService;
+    private readonly _univerInstanceService;
+    private readonly _entities;
+    private readonly _entityInit$;
+    constructor(_injector: Injector, _collabSessionService: CollaborationSessionService, _univerInstanceService: IUniverInstanceService);
+    dispose(): void;
+    getCollabEntity(id: string): Nullable<CollaborationEntity>;
+    getCollabEntity$(id: string): Observable<CollaborationEntity>;
+    private _init;
+    /**
+     * Start collaboration on a document.
+     *
+     * @param unitID ID of the document to start collaboration.
+     * @returns A disposable to stop collaboration.
+     */
+    private _startCollaboration;
+    private _getCtorByUniverType;
+}
+
+/**
+ * Each univer document instance would map to an `CollaborationEntity` to handle collaborated editing events.
+ */
+export declare abstract class CollaborationEntity extends RxDisposable {
+    readonly unitID: string;
+    readonly session: CollaborationSession;
+    protected readonly _type: UniverType;
+    protected readonly _injector: Injector;
+    protected readonly _localCacheService: LocalCacheService;
+    protected readonly _compressMutationService: CompressMutationService;
+    protected readonly _localeService: LocaleService;
+    protected readonly _revisionService: RevisionService;
+    protected readonly _logService: ILogService;
+    protected readonly _commandService: ICommandService;
+    protected readonly _messageService: IMessageService;
+    private _permissionService;
+    protected readonly _singleActiveUnitService?: ISingleActiveUnitService | undefined;
+    protected _state$: BehaviorSubject<Nullable<CollaborationState>>;
+    readonly state$: Observable<Nullable<CollaborationState>>;
+    protected _state: CollaborationState;
+    get state(): CollaborationState;
+    protected _collaborationPaused: boolean;
+    protected _changesetSessionId: string;
+    protected _changesetReqId: number;
+    readonly status$: Observable<CollaborationStatus>;
+    constructor(unitID: string, session: CollaborationSession, _type: UniverType, _injector: Injector, _localCacheService: LocalCacheService, _compressMutationService: CompressMutationService, _localeService: LocaleService, _revisionService: RevisionService, _logService: ILogService, _commandService: ICommandService, _messageService: IMessageService, _permissionService: IPermissionService, _singleActiveUnitService?: ISingleActiveUnitService | undefined);
+    init(): Promise<void>;
+    /**
+     * Pause collaboration on the document. Remote changesets would be inserted to a queue and wait for resuming.
+     * @returns a disposable which will resume collaboration when called.
+     */
+    pauseCollaboration(): IDisposable;
+    private _updateState;
+    protected _init(): Promise<CollaborationState>;
+    /**
+     * Could not transit the state twice at the same time. So we put a lock here in case of implementation fault.
+     */
+    private _transitionLocked;
+    private _unlockTransition;
+    private _lockTransition;
+    protected _onLocalMutation(command: IMutationInfo): void;
+    private _remoteChangesetQueue;
+    private _onRemoteChangeset;
+    private _exhaustRemoteChangesetQueue;
+    private _applyRemoteChangeset;
+    private _onRemoteACK;
+    private _onRemoteRejected;
+    private _onRemoteRetry;
+    private _onFetchMissResult;
+    private _toggleOffline;
+    private _toggleOnline;
+    private _createInitialState;
+    protected _createHandler(): ICollaborationStateHandler;
+    private _createInitialStateImpl;
+    private _replayCachedMutations;
+}
+
+/**
+ * The data structure to represent a collaboration session. It also manages the collaborator's identity.
+ *
+ * An collaboration session maps to a unit.
+ */
+export declare class CollaborationSession extends RxDisposable implements IDisposable {
+    private readonly _unitID;
+    private readonly _logService;
+    private readonly _beforeCloseService;
+    private readonly _messageService;
+    private readonly _configService;
+    private readonly _localeService;
+    private readonly _memberService;
+    private readonly _commentService;
+    private readonly _telemetryService?;
+    private readonly _sessionStatus$;
+    readonly sessionStatus$: Observable<SessionStatus>;
+    get sessionStatus(): SessionStatus;
+    private readonly _event$;
+    readonly event$: Observable<ICollaborationEvent>;
+    private _socket;
+    private _socketMessageSubscription;
+    constructor(_unitID: string, socket$: Observable<Nullable<ICollaborationSocket>>, _logService: ILogService, _beforeCloseService: IBeforeCloseService, _messageService: IMessageService, _configService: IConfigService, _localeService: LocaleService, _memberService: MemberService, _commentService: CommentService, _telemetryService?: ITelemetryService | undefined);
+    getMemberID(): string | null;
+    dispose(): void;
+    close(): void;
+    private _onCombEvent;
+    private _joinRoom;
+    private _onJoinRoomEvent;
+    private _onRecvEvent;
+    private _onUserJoin;
+    private _onUserLeave;
+    /**
+     * Send event to the collaboration server.
+     */
+    send(event: ICollaborationEvent, unitID: string): Promise<void>;
+    private _collaborationTimeoutTimer;
+    private _scheduleCollaborationTimeoutTimer;
+    private _clearCollaborationTimeoutTimer;
+    private _shouldReportTelemetry;
+    private _telemetryInfo;
+    private _startTelemetryCollaborationNewChangeset;
+    private _stopTelemetryCollaborationNewChangeset;
+    private _throwTelemetryCollaborationNewChangeset;
+}
+
+/**
+ * This service provide collaboration sessions to univer instances. A collaboration session
+ * may be used by different controllers of different features.
+ */
+export declare class CollaborationSessionService extends Disposable_2 {
+    private readonly _injector;
+    private readonly _localeService;
+    private readonly _messageService;
+    private readonly _logService;
+    private readonly _configService;
+    private readonly _socketService;
+    /**
+     * Socket for collaboration sessions. Session are by unitID but the socket is share by collaboration sessions.
+     */
+    private _socket$;
+    readonly socket$: Observable<Nullable<ICollaborationSocket>>;
+    private get _socket();
+    private _candidateSocket;
+    private _sessions;
+    private _status$;
+    status$: Observable<SessionStatus>;
+    private _socketReady;
+    private _retryConnectingTimer;
+    private _retryCount;
+    constructor(_injector: Injector, _localeService: LocaleService, _messageService: IMessageService, _logService: ILogService, _configService: IConfigService, _socketService: ICollaborationSocketService);
+    private _initEventListeners;
+    dispose(): void;
+    /**
+     * Require a collaboration session.
+     * @param unitID
+     * @returns a collaboration session.
+     */
+    requireSession(unitID: string): Promise<CollaborationSession>;
+    closeSession(unitID: string): void;
+    reconnect(): void;
+    private _createSocket;
+    /**
+     * Try to establish connection to the collaboration server.
+     *
+     * Will send heartbeat channel to the server to keep the connection alive.
+     */
+    private _tryEnsureSocket;
+    private _onConnectionOpen;
+    private _listenToOfflineEvent;
+    private _onOffline;
+    private _onConnectionFailed;
+    private _listenToOnlineEvent;
+    private _tryReconnect;
+    private _onMessage;
+    private _sendHeartbeatTimer;
+    private _timeoutTimer;
+    private _rescheduleHeartbeat;
+    private _sendHeartbeat;
+    private _waitForHeartbeatResponse;
+    private _clearHeartbeatTimer;
+    private _clearTimeoutTimer;
+}
+
+export declare class CollaborationSocketService extends Disposable_2 implements ICollaborationSocketService {
+    protected readonly _http: HTTPService;
+    protected readonly _ws: WebSocketService;
+    protected readonly _configService: IConfigService;
+    protected readonly _logService: ILogService;
+    protected readonly _snapshotServerService: ISnapshotServerService;
+    constructor(_http: HTTPService, _ws: WebSocketService, _configService: IConfigService, _logService: ILogService, _snapshotServerService: ISnapshotServerService);
+    /**
+     * Create a socket that would connect to the remote collaboration server. It would throw an error when the socket cannot be created.
+     *
+     * @param URL The URL of the remote server.
+     */
+    createSocket(URL: string): Nullable<ICollaborationSocket>;
+    protected _submitChangeset(socket: ICollaborationSocket, event: ISubmitChangesetEvent): Promise<void>;
+    protected _fetchMissChangesets(event: IFetchingMissEvent): Promise<IChangeset_2[]>;
+}
+
+/**
+ * Use state machine to manage syncing states.
+ * An explanation to how these states are transformed to each other.
+ */
+declare abstract class CollaborationState {
+    readonly unitID: string;
+    readonly type: UniverType;
+    /** State may change internally. Parent module should provide a callback to handle this event.  */
+    protected readonly _handler: ICollaborationStateHandler;
+    protected readonly _commandService: ICommandService;
+    protected readonly _undoRedoService: ICollaborativeUndoRedoService;
+    protected readonly _revisionService: RevisionService;
+    protected readonly _localCacheService: LocalCacheService;
+    abstract readonly status: CollaborationStatus;
+    /** Mutations that has been sent to the server but not yet acknowledged by the server.  */
+    protected _awaitingChangeset: Nullable<IChangeset>;
+    /** Mutations that has not been sent to the server. */
+    protected _pendingMutations: IMutationInfo[];
+    constructor(unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, pendingMutations: IMutationInfo[], 
+    /** State may change internally. Parent module should provide a callback to handle this event.  */
+    _handler: ICollaborationStateHandler, _commandService: ICommandService, _undoRedoService: ICollaborativeUndoRedoService, _revisionService: RevisionService, _localCacheService: LocalCacheService);
+    abstract resend(): void;
+    /**
+     * Append a location mutation to collaboration queue.
+     *
+     * @param mutation a mutation that happened locally and should be broadcasted to other peers
+     */
+    abstract appendMutation(mutation: IMutationInfo): CollaborationState;
+    /**
+     * Received a changeset from the server.
+     * @param changeset
+     */
+    abstract onRemoteChangeset(changeset: IChangeset): CollaborationState;
+    /**
+     * Received an acknowledgement from the server.
+     */
+    abstract onRemoteAck(changeset: IAcknowledgedChangeset): CollaborationState;
+    /**
+     * Received a rejection from the server, meaning that conflict could be resolved by the algorithm.
+     */
+    abstract onRemoteRej(config?: {
+        isPermissionRej: boolean;
+    }): CollaborationState;
+    /**
+     * Received a retry message from the server, meaning that some unexpected error occurred in server.
+     */
+    abstract onRemoteRetry(changeset: IChangeset): CollaborationState;
+    abstract toggleOffline(): CollaborationState;
+    abstract toggleOnline(): CollaborationState;
+    /**
+     * Check if there are some changesets missing. If true, the state should abort this changeset and request
+     * for missing changesets. Missing changesets will later be passed to `onRemoteChangeset` method.
+     *
+     * @param changeset The changeset sent from the remote collaboration server.
+     * @returns There is some changeset missing.
+     */
+    protected _checkMissing(changeset: IChangeset | IAcknowledgedChangeset): boolean;
+    /** Transform undo redo mutations in the undo redo stack.  */
+    protected _transformUndoredo(changeset: IChangeset): void;
+    /** Transform selections by calling the selection manager service. */
+    protected _transformSelections(changeset: IChangeset): void;
+    protected _transformIMECache(changeset: IChangeset): void | undefined;
+    protected _transformStateCache(changeset: IChangeset): void | undefined;
+    protected _transformRemoteChangesetByIMECache(changeset: IChangeset): IChangeset;
+    protected _transformRemoteChangesetByStateCache(changeset: IChangeset): IChangeset;
+    protected _syncEditingCollabCursor(changeset: IChangeset): void;
+    /* Excluded from this release type: _updateLocalCache */
+    protected _getCurrentRevision(): number;
+    protected _incrementRevisionNumber(): void;
+    protected _executeRemoteChangeset(changeset: IChangeset): void;
+}
+
+export declare enum CollaborationStatus {
+    NOT_COLLAB = "not_collab",
+    SYNCED = "synced",
+    PENDING = "pending",
+    AWAITING = "awaiting",
+    AWAITING_WITH_PENDING = "awaiting_with_pending",
+    FETCH_MISS = "fetch_missing",
+    CONFLICT = "conflict",
+    OFFLINE = "offline"
+}
+
+/**
+ * A component to display collaboration status to users.
+ */
+export declare function CollaborationStatusDisplay(props: Readonly<IOnlineStatusProps>): JSX.Element;
+
+export declare class CommentService {
+    private readonly _commentUpdate$;
+    readonly commentUpdate$: Observable<ICommentUpdate>;
+    onCommentUpdate(data: ICommentUpdate): void;
+}
+
+/**
+ * This controller loads data when URL changes.
+ */
+export declare class DataLoaderController extends RxDisposable {
+    private _urlService;
+    private readonly _logService;
+    private readonly _commandService;
+    private readonly _localCacheService;
+    private readonly _snapshotService;
+    constructor(_urlService: IURLService, _logService: ILogService, _commandService: ICommandService, _localCacheService: LocalCacheService, _snapshotService: SnapshotService, remoteInstanceService?: IRemoteInstanceService);
+    private _init;
+    private _setupSubUnitSync;
+    private _updateURLWithCurrentState;
+    private _updateSubUnitFromURLParams;
+    private _loadSheet;
+    private _loadDoc;
+}
+
+export declare function deserializeToCombResponse(event: MessageEvent): ICombResponseEvent;
+
+/**
+ * This controller is responsible for monitoring the collaboration status of the currently focused unit.
+ */
+export declare class DesktopCollaborationStatusDisplayController extends Disposable_2 {
+    private readonly _univerInstanceService;
+    private readonly _uiPartsService;
+    private readonly _injector;
+    private readonly _collaborationController;
+    protected readonly _status$: BehaviorSubject<CollaborationStatus>;
+    constructor(_univerInstanceService: IUniverInstanceService, _uiPartsService: IUIPartsService, _injector: Injector, _collaborationController: CollaborationController);
+    private _initStatusListener;
+    protected _initStatusComponent(): void;
+}
+
+export declare class DocCollaborationEntity extends CollaborationEntity {
+    readonly unitID: string;
+    readonly type: UniverType;
+    private readonly _docStateChangeManagerService;
+    private readonly _docTransformIMECacheService;
+    private readonly _docTransformStateCacheService;
+    private readonly _docTransformSelectionsService;
+    private readonly _docSyncEditingCollabCursorService;
+    constructor(unitID: string, type: UniverType, session: CollaborationSession, injector: Injector, localCacheService: LocalCacheService, compressMutationService: CompressMutationService, localeService: LocaleService, revisionService: RevisionService, _docStateChangeManagerService: DocStateChangeManagerService, _docTransformIMECacheService: DocTransformIMECacheService, _docTransformStateCacheService: DocTransformStateCacheService, _docTransformSelectionsService: DocTransformSelectionsService, _docSyncEditingCollabCursorService: DocSyncEditingCollabCursorService, logService: ILogService, commandService: ICommandService, messageService: IMessageService, permissionService: IPermissionService, singleActiveUnitService?: ISingleActiveUnitService);
+    protected _createHandler(): ICollaborationStateHandler;
+    protected _init(): Promise<CollaborationState>;
+}
+
+declare class DocSyncEditingCollabCursorService extends RxDisposable {
+    private readonly _collabCursorState$;
+    readonly collabCursorState$: Observable<Nullable<IUpdateCursor>>;
+    syncEditingCollabCursor(collabCursor: ICollabEditingCursor): void;
+}
+
+declare class DocTransformIMECacheService {
+    private readonly _injector;
+    private readonly _transformService;
+    private readonly _renderManagerService;
+    constructor(_injector: Injector, _transformService: ITransformService, _renderManagerService: IRenderManagerService);
+    transformIMECache(changeset: IChangeset): void;
+    transformRemoteChangeset(changeset: IChangeset): IChangeset;
+    private _transformUndoRedoStack;
+    private _transformPreviousActiveRange;
+}
+
+declare class DocTransformSelectionsService {
+    private readonly _injector;
+    private readonly _transformService;
+    constructor(_injector: Injector, _transformService: ITransformService);
+    transformSelections(changeset: IChangeset): void;
+}
+
+declare class DocTransformStateCacheService {
+    private readonly _injector;
+    private readonly _transformService;
+    private readonly _docStateChangeManagerService;
+    constructor(_injector: Injector, _transformService: ITransformService, _docStateChangeManagerService: DocStateChangeManagerService);
+    transformStateCache(changeset: IChangeset): void;
+    transformRemoteChangeset(changeset: IChangeset): IChangeset;
+    private _transformHistoryAndStateStack;
+}
+
+/** The heartbeat interval in milliseconds. */
+export declare const HEARTBEAT_INTERVAL_KEY = "HEARTBEAT_INTERVAL";
+
+export declare const HEARTBEAT_TIMEOUT_KEY = "HEARTBEAT_TIMEOUT";
+
+declare interface ICollabEditingCursor {
+    unitID: string;
+    memberID: string;
+    textRanges: ITextRangeWithStyle[];
+}
+
+export declare interface ICollaborationSocket extends Pick<ISocket, 'open$' | 'error$' | 'close$'> {
+    memberID: string;
+    message$: Observable<ICombResponseEvent>;
+    send: (event: ICombRequestEvent) => void;
+    close: () => void;
+}
+
+/**
+ * This service provides a socket that can be used to communicate with the remote collaboration server.
+ */
+export declare interface ICollaborationSocketService {
+    createSocket: (url: string) => Nullable<ICollaborationSocket>;
+}
+
+export declare const ICollaborationSocketService: IdentifierDecorator<ICollaborationSocketService>;
+
+declare interface ICollaborationStateHandler {
+    onStateChange: StateChangeHandler;
+    onSendChangeset: SendChangesetHandler;
+    onMissingChangesets: MissingChangesetsHandler;
+    onTransformSelections?: TransformSelectionsHandler;
+    onTransformIME?: TransformIMEHandler;
+    onTransformState?: TransformStateHandler;
+    onSyncEditingCollabCursor?: SyncEditingCollabCursorHandler;
+    onTransformRemoteChangesetByIMECache?: TransformRemoteChangesetByIMECache;
+    onTransformRemoteChangesetByStateCache?: TransformRemoteChangesetByStateCache;
+}
+
+/**
+ * `LocalUndoRedoService` cannot transform mutations in the undo redo stack under collaboration conditions.
+ */
+declare interface ICollaborativeUndoRedoService extends IUndoRedoService {
+    transformUndoRedo: (unitID: string, changeset: IChangeset) => void;
+}
+
+export declare class ImageIoService implements IImageIoService {
+    private readonly _httpService;
+    private readonly _configService;
+    private readonly _univerInstanceService;
+    private _waitCount;
+    private _change$;
+    change$: Observable<number>;
+    constructor(_httpService: HTTPService, _configService: IConfigService, _univerInstanceService: IUniverInstanceService);
+    setWaitCount(count: number): void;
+    private _imageSourceCache;
+    getImageSourceCache(source: string, imageSourceType: ImageSourceType): HTMLImageElement | undefined;
+    addImageSourceCache(source: string, imageSourceType: ImageSourceType, imageSource: Nullable<HTMLImageElement>): void;
+    getImage(imageId: string): Promise<string>;
+    saveImage(imageFile: File): Promise<Nullable<IImageIoServiceParam>>;
+    private _getUploadFileURL;
+    private _getSignURL;
+    private _getDownloadEndpointURL;
+    private _replaceFileID;
+    private _decreaseWaiting;
+}
+
+declare interface IOnlineStatusProps {
+    /** The collaboration state of the currently focused unit. */
+    status$: Observable<CollaborationStatus>;
+}
+
+/**
+ * The data structure to store collab cursor info of sheet.
+ */
+declare interface ISheetCollabCursor {
+    /** Stroke color of this collab cursor */
+    color: string;
+    /** Position of this cursor */
+    range: IRange;
+    /** Displayed user name of this cursor */
+    name: string;
+    /** The serialized range to check if two cursor are on the same position. */
+    selection: string;
+    /** Worksheet ID */
+    sheetID: string;
+    /** Background color of this collab cursor */
+    backgroundColor?: string;
+}
+
+export declare interface ISheetCollabCursorShapeProps extends IShapeProps, ISheetCollabCursor {
+    hovered?: boolean;
+    labelPosition?: 'bottom' | 'top';
+}
+
+/**
+ * It is not recommended to open multiple units in different browser tabs at the same time,
+ * especially when the there is not access to the internet. There is a great chance of loosing
+ * offline data! So we should make there is only one active unit at a time.
+ */
+declare const ISingleActiveUnitService: IdentifierDecorator<ISingleActiveUnitService>;
+
+declare interface ISingleActiveUnitService {
+    editingUnit: (unitID: string) => void;
+    getUnitStatus$: (unitID: string) => Observable<UnitStatus>;
+}
+
+declare interface IUnitCacheData {
+    unitID: string;
+    type: UniverType;
+    rev: number;
+    awaitingChangeset: Nullable<IChangeset>;
+    mutations: IMutationInfo[];
+}
+
+export declare interface IUniverCollaborationClientConfig {
+    socketService?: Ctor<ICollaborationSocketService>;
+    enableOfflineEditing?: boolean;
+    enableSingleActiveInstanceLock?: boolean;
+    enableAuthServer?: boolean;
+    /**
+     * Override internal modules with custom implementations.
+     */
+    override?: DependencyOverride;
+    sendChangesetTimeout?: number;
+    snapshotServerUrl?: string;
+    collabSubmitChangesetUrl?: string;
+    collabWebSocketUrl?: string;
+    loginUrlKey?: string;
+    retryConnectingInterval?: number;
+    authzUrl?: string;
+    /**
+     * The URL of the endpoint for downloading files.
+     * @default 'location.origin'
+     */
+    downloadEndpointUrl?: string;
+    uploadFileServerUrl?: string;
+    signUrlServerUrl?: string;
+}
+
+/**
+ * This service reads the url from the host platform and return url parts,
+ * such as queries, hashes and path.
+ */
+export declare interface IURLService {
+    getParam: (key: string) => string | undefined;
+    setParam: (key: string, value: string, useReplace?: boolean) => void;
+    removeParam: (key: string, useReplace?: boolean) => void;
+    urlChange$: Observable<void>;
+}
+
+export declare const IURLService: IdentifierDecorator<IURLService>;
+
+declare interface IUser extends IMember {
+    userID: string;
+}
+
+/**
+ * A config key to determine how often should Univer save local edits.
+ */
+export declare const LOCAL_CACHE_INTERVAL_KEY = "LOCAL_CACHE_INTERVAL";
+
+/**
+ * This service provide caching to the collaboration controller.
+ */
+export declare class LocalCacheService extends Disposable_2 {
+    private readonly _configService;
+    private readonly _localStorageService;
+    private readonly _beforeCloseService;
+    private readonly _localeService;
+    private readonly _revisionService;
+    private _cachedData;
+    private _saveTaskMap;
+    private _disabled;
+    constructor(_configService: IConfigService, _localStorageService: ILocalStorageService, _beforeCloseService: IBeforeCloseService, _localeService: LocaleService, _revisionService: RevisionService);
+    disableLocalCache(): void;
+    enableLocalCache(): void;
+    dispose(): void;
+    loadOfflineData(unitID: string): Promise<Nullable<IUnitCacheData>>;
+    saveOfflineData(unitID: string, data: IUnitCacheData): Promise<boolean>;
+    updateOfflineData(unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, pendingMutations: IMutationInfo[]): void;
+    private _scheduleSaving;
+    private _getSaveTimeout;
+    private _saveCache;
+    exhaustSavingTask(): Promise<void>;
+    private _setupBeforeClosingHandler;
+}
+
+/** @deprecated Will be removed in the 0.2.19 release */
+export declare const LOGIN_URL_KEY = "LOGIN_URL_KEY";
+
+/**
+ * This services manages members is each rooms.
+ */
+export declare class MemberService extends Disposable_2 {
+    private readonly _univerInstanceService;
+    private _userManagerService;
+    private _roomMembers;
+    constructor(_univerInstanceService: IUniverInstanceService, _userManagerService: UserManagerService);
+    /**
+     * @deprecated please use userManagerService
+     */
+    setCurrentUser(user: IUser): void;
+    /**
+     * @deprecated please use userManagerService
+     */
+    getCurrentUser(): Nullable<IUser>;
+    /**
+     * Update a member in a room(unit).
+     * @param roomID i.e. unitID.
+     * @param member member object to be updated.
+     */
+    updateMember(roomID: string, member: IMember): void;
+    /**
+     * Remove a member from a room(unit).
+     * @param roomID i.e. unitID.
+     * @param memberID memberID of the member to be removed.
+     */
+    removeMember(roomID: string, memberID: string): void;
+    /**
+     * Get RoomMember for a unit.
+     * @param roomID which is same with unitId.
+     * @returns RoomMember which is a object that manages members in a single room.
+     */
+    getRoom(roomID: string): RoomMember | undefined;
+    /**
+     * Get a member in a room(unit).
+     * @param roomID i.e. unitID.
+     * @param memberID memberID of the member to be retrieved.
+     * @returns member object.
+     */
+    getMember(roomID: string, memberID: string): IMember | undefined;
+    private _removeRoom;
+    dispose(): void;
+}
+
+declare type MissingChangesetsHandler = (params: {
+    from: number;
+    to: number;
+}) => void;
+
+export declare const RETRY_CONNECTING_MAX_COUNT_KEY = "RETRY_CONNECTING_MAX_COUNT";
+
+/**
+ * This class manages members is a single room.
+ */
+declare class RoomMember extends Disposable_2 {
+    private readonly _members;
+    dispose(): void;
+    /**
+     * Update a member in the room(unit).
+     * @param member member object to be updated.
+     */
+    updateMember(member: IMember): void;
+    /**
+     * Remove a member from the room(unit).
+     * @param memberID memberID of the member to be removed.
+     */
+    removeMember(memberID: string): void;
+    /**
+     * Get a member by memberID.
+     * @param memberID
+     * @returns member object.
+     */
+    getMember(memberID: string): IMember | undefined;
+    /**
+     * Get all members in the room(unit).
+     * @returns member object array.
+     */
+    getAllMembers(): IMember[];
+}
+
+/** @deprecated Will be removed in the 0.2.19 release */
+export declare const SEND_CHANGESET_TIMEOUT_KEY = "SEND_CHANGESET_TIMEOUT";
+
+/** A network interface to send changeset and  */
+declare type SendChangesetHandler = (changeset: IChangeset) => void;
+
+export declare function serializeCombRequest(event: ICombRequestEvent): string;
+
+export declare enum SessionStatus {
+    IDLE = 0,
+    JOINING = 1,
+    OFFLINE = 2,
+    ONLINE = 3
+}
+
+/**
+ * Render a single collaborated cursor on the canvas.
+ */
+export declare class SheetCollabCursorShape<T extends ISheetCollabCursorShapeProps = ISheetCollabCursorShapeProps> extends Shape<T> {
+    private _color;
+    private _hovered;
+    private _range;
+    private _name;
+    private _labelPosition;
+    private _backgroundColor?;
+    constructor(key?: string, props?: T);
+    setShapeProps(props: Partial<ISheetCollabCursorShapeProps>): void;
+    onMouseMove(position: {
+        row: number;
+        column: number;
+    }): void;
+    triggerDblclick(evt: IPointerEvent | IMouseEvent): boolean;
+    protected _draw(ctx: CanvasRenderingContext2D): void;
+}
+
+export declare class SheetCollaborationEntity extends CollaborationEntity {
+    readonly unitID: string;
+    readonly type: UniverType;
+    private readonly _sheetTransformSelectionsService;
+    constructor(unitID: string, type: UniverType, session: CollaborationSession, injector: Injector, localCacheService: LocalCacheService, compressMutationService: CompressMutationService, localeService: LocaleService, revisionService: RevisionService, _sheetTransformSelectionsService: SheetTransformSelectionsService, logService: ILogService, commandService: ICommandService, messageService: IMessageService, permissionService: IPermissionService, singleActiveUnitService?: ISingleActiveUnitService);
+    protected _createHandler(): ICollaborationStateHandler;
+    protected _init(): Promise<CollaborationState>;
+}
+
+declare class SheetTransformSelectionsService {
+    private readonly _injector;
+    private readonly _transformService;
+    private readonly _instanceService;
+    constructor(_injector: Injector, _transformService: ITransformService, _instanceService: IUniverInstanceService);
+    transformSelections(changeset: IChangeset): void;
+}
+
+/** @deprecated Will be removed in the 0.2.19 release */
+export declare const SNAPSHOT_SERVER_URL_KEY = "SNAPSHOT_SERVER_URL_KEY";
+
+/**
+ * @ignore
+ */
+export declare const SNAPSHOT_URL_KEY = "SNAPSHOT_URL_KEY";
+
+export declare class SnapshotServerOverHTTPService implements ISnapshotServerService {
+    private readonly _configService;
+    private readonly _httpService;
+    constructor(_configService: IConfigService, _httpService: HTTPService);
+    getUnitOnRev(_context: ILogContext, params: IGetUnitOnRevRequest): Promise<IGetUnitOnRevResponse>;
+    getSheetBlock(_context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetSheetBlockResponse>;
+    getDeserializedSheetBlock(_context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetDeserializedSheetBlockResponse>;
+    fetchMissingChangesets(_context: ILogContext, params: IFetchMissingChangesetsRequest): Promise<IFetchMissingChangesetsResponse>;
+    private _getSnapshotAPIPrefix;
+    private _getAPIPrefix;
+    getResourcesRequest(_context: ILogContext, params: IGetResourcesRequest): Promise<IGetResourcesResponse>;
+    saveSnapshot(): Promise<ISaveSnapshotResponse>;
+    saveSheetBlock(): Promise<ISaveSheetBlockResponse>;
+    saveChangeset(): Promise<ISaveChangesetResponse>;
+    copyFileMeta(): Promise<ICopyFileMetaResponse>;
+    getLatestCsReqIdBySid(): Promise<IGetLatestCsReqIdBySidResponse>;
+}
+
+/** Provide both states when and after changing, so the parent could examine if state transition is correct. */
+declare type StateChangeHandler = (before: CollaborationState, after: CollaborationState) => void;
+
+declare type SyncEditingCollabCursorHandler = (params: ICollabEditingCursor) => void;
+
+declare type TransformIMEHandler = (changeset: IChangeset) => void;
+
+declare type TransformRemoteChangesetByIMECache = (changeset: IChangeset) => IChangeset;
+
+declare type TransformRemoteChangesetByStateCache = (changeset: IChangeset) => IChangeset;
+
+declare type TransformSelectionsHandler = (changeset: IChangeset) => void;
+
+declare type TransformStateHandler = (changeset: IChangeset) => void;
+
+declare enum UnitStatus {
+    NO_OTHER_CLIENTS_EDITING = 0,
+    OTHER_CLIENTS_EDITING = 1
+}
+
+export declare class UniverCollaborationClientPlugin extends Plugin_2 {
+    private readonly _config;
+    private readonly _logService;
+    private readonly _renderManagerService;
+    protected _injector: Injector;
+    private readonly _configService;
+    static pluginName: string;
+    constructor(_config: Partial<IUniverCollaborationClientConfig> | undefined, _logService: ILogService, _renderManagerService: IRenderManagerService, _injector: Injector, _configService: IConfigService);
+    onStarting(): void;
+    onReady(): void;
+    onRendered(): void;
+    private _registerDependencies;
+    private _registerRenderDependencies;
+    private _initDependencies;
+}
+
+export declare class WebURLService extends RxDisposable implements IURLService {
+    readonly urlChange$: Observable<void>;
+    constructor();
+    setParam(key: string, value: string, useReplace?: boolean): void;
+    removeParam(key: string, useReplace?: boolean): void;
+    getParam(key: string): string | undefined;
+}
+
+export { }