@fileverse-dev/ddoc 3.0.67 → 3.0.69-rtc-patch-2

package/dist/package/hooks/use-tab-editor.d.ts

@@ -2,7 +2,7 @@ import { Dispatch, MutableRefObject, SetStateAction } from 'react';
 import { DdocProps } from '../types';
 import { AnyExtension, Editor } from '@tiptap/react';
 import { ToCItemType } from '../components/toc/types';
-import { IConnectConf } from '../sync-local/useSyncMachine';
+import { CollabConnectionConfig, CollaborationProps } from '../sync-local/types';
 
 import * as Y from 'yjs';
 interface UseTabEditorArgs {
@@ -12,8 +12,7 @@ interface UseTabEditorArgs {
     versionId?: string;
     isPreviewMode?: boolean;
     initialContent: DdocProps['initialContent'];
-    enableCollaboration?: boolean;
-    collabConfig?: DdocProps['collabConfig'];
+    collaboration?: CollaborationProps;
     isReady?: boolean;
     awareness?: any;
     disableInlineComment?: boolean;
@@ -38,7 +37,7 @@ interface UseTabEditorArgs {
     onInvalidContentError?: DdocProps['onInvalidContentError'];
     ignoreCorruptedData?: boolean;
     onCollaboratorChange?: DdocProps['onCollaboratorChange'];
-    onConnect: (connectConfig: IConnectConf) => void;
+    onConnect: (connectConfig: CollabConnectionConfig) => void;
     hasCollabContentInitialised?: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;
     externalExtensions?: Record<string, AnyExtension>;
@@ -47,7 +46,7 @@ interface UseTabEditorArgs {
     theme?: 'dark' | 'light';
     editorRef?: MutableRefObject<Editor | null>;
 }
-export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, initialContent, enableCollaboration, collabConfig, isReady, awareness, disableInlineComment, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, }: UseTabEditorArgs) => {
+export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, initialContent, collaboration, isReady, awareness, disableInlineComment, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, }: UseTabEditorArgs) => {
     editor: Editor | null;
     ref: import('react').RefObject<HTMLDivElement>;
     slides: string[];

package/dist/package/hooks/use-tab-manager.d.ts

@@ -5,7 +5,7 @@ import * as Y from 'yjs';
 interface UseTabManagerArgs {
     ydoc: Y.Doc;
     initialContent: DdocProps['initialContent'];
-    enableCollaboration: DdocProps['enableCollaboration'];
+    enableCollaboration?: boolean;
     isDDocOwner: boolean;
     createDefaultTabIfMissing: boolean;
     shouldSyncActiveTab: boolean;

package/dist/package/hooks/use-yjs-setup.d.ts

@@ -1,27 +1,22 @@
 import { JSONContent } from '@tiptap/react';
-import { DdocProps } from '../types';
+import { CollaborationProps } from '../sync-local/types';
 import * as Y from 'yjs';
 interface UseYjsSetupArgs {
     onChange?: (updatedDocContent: string | JSONContent, updateChunk: string) => void;
     enableIndexeddbSync?: boolean;
     ddocId?: string;
-    enableCollaboration?: boolean;
+    collaboration?: CollaborationProps;
     onIndexedDbError?: (error: Error) => void;
-    onCollabError?: DdocProps['onCollabError'];
-    onCollaborationConnectCallback?: DdocProps['onCollaborationConnectCallback'];
-    onCollaborationCommit?: DdocProps['onCollaborationCommit'];
-    onFetchCommitContent?: DdocProps['onFetchCommitContent'];
-    onCollabSessionTermination?: () => void;
-    onUnMergedUpdates?: (state: boolean) => void;
 }
-export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, enableCollaboration, onIndexedDbError, onCollabError, onCollaborationConnectCallback, onCollaborationCommit, onFetchCommitContent, onCollabSessionTermination, onUnMergedUpdates, }: UseYjsSetupArgs) => {
+export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, collaboration, onIndexedDbError, }: UseYjsSetupArgs) => {
     ydoc: Y.Doc;
-    onConnect: (connectConfig: import('../sync-local/useSyncMachine').IConnectConf) => void;
+    onConnect: (connectConfig: import('../types').CollabConnectionConfig) => void;
     isReady: boolean;
     terminateSession: () => void;
-    awareness: any;
+    awareness: import('y-protocols/awareness.js').Awareness | null;
     hasCollabContentInitialised: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;
     refreshYjsIndexedDbProvider: () => Promise<void>;
+    collabState: import('../types').CollabState;
 };
 export {};

package/dist/package/sync-local/SyncManager.d.ts

@@ -0,0 +1,55 @@
+import { Awareness } from 'y-protocols/awareness.js';
+import { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollabStatus, CollabState } from './types';
+
+export declare class SyncManager {
+    private onCollabStateChange;
+    private _status;
+    private _context;
+    private _awareness;
+    private socketClient;
+    private roomKey;
+    private roomKeyBytes;
+    private isOwner;
+    private updateQueue;
+    private uncommittedUpdatesIdList;
+    private contentTobeAppliedQueue;
+    private isProcessing;
+    private _awarenessUpdateHandler;
+    private ydoc;
+    private servicesRef;
+    private callbacksRef;
+    private onLocalUpdate?;
+    constructor(config: SyncManagerConfig, onCollabStateChange: (state: CollabState) => void);
+    /** Called by useSyncManager on every render to keep refs fresh */
+    updateRefs(services: CollabServices | undefined, callbacks: CollabCallbacks | undefined, onLocalUpdate?: (updatedDocContent: string, updateChunk: string) => void): void;
+    get isConnected(): boolean;
+    get isReady(): boolean;
+    get awareness(): Awareness | null;
+    get status(): CollabStatus;
+    get collabState(): CollabState;
+    private send;
+    private runExitActions;
+    private runEntryActions;
+    connect(config: CollabConnectionConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    terminateSession(): Promise<void>;
+    enqueueLocalUpdate(update: Uint8Array): void;
+    forceCleanup(): void;
+    private handleConnectionError;
+    private handleReconnection;
+    private connectSocket;
+    private syncLatestCommit;
+    private initializeAwareness;
+    private cleanupAwareness;
+    private commitLocalContents;
+    private broadcastLocalContents;
+    private processUpdateQueue;
+    private processNextUpdate;
+    private processCommit;
+    private handleRemoteContentUpdate;
+    private applyRemoteYjsUpdate;
+    private applyQueuedRemoteContents;
+    private withRetry;
+    private disconnectInternal;
+    private resetInternalState;
+}

package/dist/package/sync-local/collabStateMachine.d.ts

@@ -0,0 +1,23 @@
+import { CollabStatus, CollabEvent, CollabContext, CollabState, CollabErrorCode } from './types';
+
+export declare const INITIAL_CONTEXT: CollabContext;
+type TransitionResult = {
+    status: CollabStatus;
+    context: Partial<CollabContext>;
+} | null;
+/**
+ * Transition map: (currentStatus, eventType) → nextStatus + context mutations.
+ * Returns null if the transition is invalid.
+ */
+export declare function transition(currentStatus: CollabStatus, event: CollabEvent, context: CollabContext): TransitionResult;
+/**
+ * Derives the consumer-facing CollabState from internal status + context.
+ */
+export declare function deriveCollabState(status: CollabStatus, context: CollabContext): CollabState;
+/** Helper to create a CollabError */
+export declare function createCollabError(code: CollabErrorCode, message: string, recoverable?: boolean): {
+    code: CollabErrorCode;
+    message: string;
+    recoverable: boolean;
+};
+export {};

package/dist/package/sync-local/index.d.ts

@@ -1,6 +1,3 @@
-import { default as syncMachine } from './syncMachine';
-import { SyncMachineContext } from './types';
-
-export { useSyncMachine } from './useSyncMachine';
-export { syncMachine };
-export type { SyncMachineContext };
+export { useSyncManager } from './useSyncManager';
+export { SyncManager } from './SyncManager';
+export type { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollaborationProps, CollabSessionMeta, CollabStatus, CollabState, CollabError, CollabErrorCode, CollabEvent, CollabContext, } from './types';

package/dist/package/sync-local/socketClient.d.ts

@@ -1,14 +1,17 @@
-import { UrlProvider } from 'partysocket/ws';
-import { ISocketInitConfig, RoomMember, SocketStatusEnum, SendUpdateResponse, CommitResponse } from './types';
+import { ISocketInitConfig, RoomMember, SocketStatusEnum, SendUpdateResponse, CommitResponse, AckResponse } from './types';
 import { Awareness } from 'y-protocols/awareness.js';
 
 interface ISocketClientConfig {
-    wsUrl: UrlProvider;
+    wsUrl: string;
     roomKey: string;
+    roomId: string;
     ownerEdSecret?: string;
     contractAddress?: string;
     ownerAddress?: string;
-    onCollaborationConnectCallback: (response: any) => void;
+    onHandshakeData?: (response: {
+        data: AckResponse;
+        roomKey: string;
+    }) => void;
     roomInfo?: {
         documentTitle: string;
         portalAddress: string;
@@ -16,14 +19,12 @@ interface ISocketClientConfig {
     };
 }
 export declare class SocketClient {
-    private _websocketUrl;
-    private _machineEventHandler;
-    private _onConnect;
-    private _onDisconnection;
-    private _onHandShakeError;
-    private _sequenceCallbackMap;
-    _webSocketStatus: SocketStatusEnum;
-    private _webSocket;
+    private _socketUrl;
+    private _socket;
+    private _webSocketStatus;
+    private _isIntentionalDisconnect;
+    get isConnected(): boolean;
+    get status(): SocketStatusEnum;
     private _websocketServiceDid;
     private roomId;
     roomMembers: RoomMember[];
@@ -36,14 +37,11 @@ export declare class SocketClient {
     private roomKey;
     private roomInfo?;
     private awareness;
-    _onError: ISocketInitConfig['onError'] | null;
-    _onCollaborationConnectCallback: ISocketClientConfig['onCollaborationConnectCallback'] | null;
+    private connectionAttemptErrorCount;
+    private _onHandshakeData;
     constructor(config: ISocketClientConfig);
-    private _getSequenceIdCallback;
-    private _removeSequenceIdFromMap;
     registerAwareness(awareness: Awareness): void;
-    private _registerSequenceCallback;
-    private _sendNetworkRequest;
+    private _emitWithAck;
     private _fetchRoomMembers;
     sendUpdate({ update }: {
         update: string;
@@ -52,24 +50,19 @@ export declare class SocketClient {
         updates: string[];
         cid: string;
     }): Promise<CommitResponse>;
-    fetchLatestCommit(): Promise<any>;
-    getUncommittedChanges(): Promise<any>;
-    broadcastAwareness(awarenessUpdate: string): Promise<any>;
-    disconnect: (reason: string, code: number) => void;
+    fetchLatestCommit(): Promise<AckResponse<any>>;
+    getUncommittedChanges(): Promise<AckResponse<any>>;
+    broadcastAwareness(awarenessUpdate: string): Promise<void>;
+    disconnect: () => void;
     terminateSession: () => Promise<void>;
-    private _buildRequest;
     private getCollaborationKeyPair;
     private isUcanValid;
     private getOwnerToken;
     private buildSessionToken;
     private _handleHandShake;
-    private _executeRequestCallback;
-    private _dispatchEventHandler;
+    private _handleAwarenessUpdate;
+    connectSocket(config: ISocketInitConfig): Promise<void>;
     private _onSessionTerminated;
-    private _processMessage;
-    private _clearSequenceCallbackMap;
-    connectSocket(): Promise<void> | undefined;
-    init(config: ISocketInitConfig): Promise<void>;
     private resetSocketClient;
 }
 export {};

package/dist/package/sync-local/types/index.d.ts

@@ -1,130 +1,176 @@
-import { Data } from '../../types';
-import { SocketClient } from '../socketClient';
+import { Data, IDocCollabUsers } from '../../types';
 
 import * as Y from 'yjs';
-export interface IRoomMember {
-    userId: string;
+/** Connection identity — changes to these trigger reconnect */
+export interface CollabConnectionConfig {
+    roomKey: string;
+    roomId: string;
+    wsUrl: string;
+    isOwner: boolean;
+    ownerEdSecret?: string;
+    contractAddress?: string;
+    ownerAddress?: string;
+    roomInfo?: {
+        documentTitle: string;
+        portalAddress: string;
+        commentKey: string;
+    };
+}
+/** Session metadata — changes to these update awareness, NOT reconnect */
+export interface CollabSessionMeta {
     username: string;
-    role: 'owner' | 'editor';
+    isEns?: boolean;
 }
-export interface SendUpdateResponse {
-    data: {
-        agent_id: string;
-        commitCid: string | null;
-        created_at: number;
-        data: string;
-        documentId: string;
-        id: string;
-        update_snapshot_ref: string | null;
-        updateType: string;
-    };
-    is_handshake_response: boolean;
-    status: boolean;
-    statusCode: number;
+/** Storage integrations the sync engine depends on */
+export interface CollabServices {
+    commitToStorage?: (file: File) => Promise<string>;
+    fetchFromStorage?: (cid: string) => Promise<any>;
 }
-export interface CommitResponse {
-    data: {
-        agent_id: string;
-        cid: string;
-        created_at: number;
-        data: any | null;
-        documentId: string;
-        updates: string[];
-    };
-    is_handshake_response: boolean;
-    status: boolean;
-    statusCode: number;
+export type CollabErrorCode = 'CONNECTION_FAILED' | 'AUTH_FAILED' | 'SYNC_FAILED' | 'TIMEOUT' | 'UNKNOWN';
+export type CollabError = {
+    code: CollabErrorCode;
+    message: string;
+    recoverable: boolean;
+};
+export type CollabStatus = 'idle' | 'connecting' | 'syncing' | 'ready' | 'reconnecting' | 'error' | 'terminated';
+export type CollabState = {
+    status: 'idle';
+} | {
+    status: 'connecting';
+} | {
+    status: 'syncing';
+    hasUnmergedPeerUpdates: boolean;
+} | {
+    status: 'ready';
+} | {
+    status: 'reconnecting';
+    attempt: number;
+    maxAttempts: number;
+} | {
+    status: 'error';
+    error: CollabError;
+} | {
+    status: 'terminated';
+    reason?: string;
+};
+export type CollabEvent = {
+    type: 'CONNECT';
+} | {
+    type: 'AUTH_SUCCESS';
+} | {
+    type: 'SYNC_COMPLETE';
+} | {
+    type: 'SET_UNMERGED_UPDATES';
+    hasUpdates: boolean;
+} | {
+    type: 'SOCKET_DROPPED';
+} | {
+    type: 'RECONNECTED';
+} | {
+    type: 'RETRY_EXHAUSTED';
+} | {
+    type: 'ERROR';
+    error: CollabError;
+} | {
+    type: 'SESSION_TERMINATED';
+    reason?: string;
+} | {
+    type: 'RESET';
+};
+export interface CollabContext {
+    hasUnmergedPeerUpdates: boolean;
+    reconnectAttempt: number;
+    maxReconnectAttempts: number;
+    error: CollabError | null;
+    terminationReason?: string;
 }
-export interface SyncMachineContext {
+/** Event callbacks the consumer reacts to */
+export interface CollabCallbacks {
+    onStateChange?: (state: CollabState) => void;
+    onError?: (error: CollabError) => void;
+    onCollaboratorsChange?: (collaborators: IDocCollabUsers[]) => void;
+    onHandshakeData?: (data: {
+        data: AckResponse;
+        roomKey: string;
+    }) => void;
+}
+/** Discriminated union — TypeScript enforces config+services only when enabled */
+export type CollaborationProps = {
+    enabled: false;
+} | {
+    enabled: true;
+    connection: CollabConnectionConfig;
+    session: CollabSessionMeta;
+    services: CollabServices;
+    on?: CollabCallbacks;
+};
+export interface SyncManagerConfig {
     ydoc: Y.Doc;
-    socketClient: SocketClient | null;
-    roomId: string;
-    username: string;
-    roomMembers: IRoomMember[];
-    isConnected: boolean;
-    awareness: any;
-    _awarenessUpdateHandler: (({ added, updated, removed, }: {
-        added: number[];
-        updated: number[];
-        removed: number[];
-    }) => void) | null;
-    onError: ((e: Error) => void) | null;
-    roomKey: string;
-    wsUrl: string;
-    uncommittedUpdatesIdList: string[];
-    isOwner: boolean;
-    updateQueue: Uint8Array[];
-    isReady: boolean;
-    isNewDoc: boolean;
-    contentTobeAppliedQueue: string[];
-    initialUpdate: string | null;
-    errorCount: number;
-    errorMaxRetryCount: number;
-    errorMessage: string;
-    initalDocumentDecryptionState: 'done' | 'pending';
-    onCollaborationConnectCallback: (response: any) => void;
-    onCollaborationCommit: (file: File) => Promise<string>;
-    onFetchCommitContent: (cid: string) => Promise<any>;
-    onSessionTerminated: () => void;
-    onUnMergedUpdates: (state: boolean) => void;
+    services?: CollabServices;
+    callbacks?: CollabCallbacks;
     onLocalUpdate?: (updatedDocContent: Data['editorJSONData'], updateChunk: string) => void;
 }
-export interface ErrorResponseMessage {
-    status: boolean;
-    statusCode: number;
-    seqId: string | null;
-    is_handshake_response: boolean;
-    err: string;
-    err_detail: {
-        [key: string]: any;
-    } | null;
+export declare enum ServerErrorCode {
+    AUTH_TOKEN_MISSING = "AUTH_TOKEN_MISSING",
+    AUTH_TOKEN_INVALID = "AUTH_TOKEN_INVALID",
+    SESSION_NOT_FOUND = "SESSION_NOT_FOUND",
+    SESSION_TERMINATED = "SESSION_TERMINATED",
+    SESSION_DID_MISSING = "SESSION_DID_MISSING",
+    DOCUMENT_ID_MISSING = "DOCUMENT_ID_MISSING",
+    UPDATE_DATA_MISSING = "UPDATE_DATA_MISSING",
+    COMMIT_UNAUTHORIZED = "COMMIT_UNAUTHORIZED",
+    COMMIT_MISSING_DATA = "COMMIT_MISSING_DATA",
+    INVALID_ADDRESS = "INVALID_ADDRESS",
+    NOT_AUTHENTICATED = "NOT_AUTHENTICATED",
+    DB_ERROR = "DB_ERROR",
+    INTERNAL_ERROR = "INTERNAL_ERROR"
 }
-export interface SuccessResponseMessage {
+export interface AckResponse<T = Record<string, any>> {
     status: boolean;
     statusCode: number;
-    seqId: string | null;
-    is_handshake_response: boolean;
-    data: {
-        [key: string]: any;
-    };
-}
-export interface EventMessage {
-    type: string;
-    event_type: string;
-    event: {
-        data: any;
-        roomId: string;
-    };
-}
-export type RequestResponse = ErrorResponseMessage | SuccessResponseMessage;
-export type OnMessagePayloadType = RequestResponse | EventMessage;
-export type EventHandler = (message: EventMessage) => void;
-export type DisconnectHandler = (e: CloseEvent | ErrorEvent) => void;
-export type ConnectHandler = () => void;
-export interface PartialRequest {
-    cmd: string;
-    args: {
-        [key: string]: any;
-    };
+    data?: T;
+    error?: string;
+    errorCode?: ServerErrorCode;
 }
-export interface RequestPayload extends PartialRequest {
-    seqId: string;
+export interface SendUpdateResponse extends AckResponse<{
+    id: string;
+    documentId: string;
+    data: string;
+    updateType: string;
+    commitCid: string | null;
+    createdAt: number;
+}> {
 }
-export type SequenceResponseCB = (data: RequestResponse) => void;
-export interface SequenceToRequestMapValue {
-    callback: SequenceResponseCB;
+export interface CommitResponse extends AckResponse<{
+    cid: string;
+    createdAt: number;
+    documentId: string;
+    updates: string[];
+}> {
 }
-export type SequenceToRequestMap = {
-    [key: string]: SequenceToRequestMapValue;
-};
-export type Update = Uint8Array;
 export interface ISocketInitConfig {
-    onConnect: ConnectHandler;
-    onDisconnect: DisconnectHandler;
+    onHandshakeSuccess: () => void;
+    onDisconnect: () => void;
+    onSocketDropped: () => void;
     onError: (err: Error) => void;
-    onWsEvent: EventHandler;
-    onHandShakeError: (err: Error) => void;
-    roomId: string;
+    onHandShakeError: (err: Error, statusCode?: number) => void;
+    onContentUpdate: (data: {
+        id: string;
+        data: string;
+        createdAt: number;
+        roomId: string;
+    }) => void;
+    onMembershipChange: (data: {
+        action: string;
+        user: {
+            role: string;
+        };
+        roomId: string;
+    }) => void;
+    onSessionTerminated: (data: {
+        roomId: string;
+    }) => void;
+    onReconnectFailed: () => void;
 }
 export declare enum SocketStatusEnum {
     CLOSED = "CLOSED",
@@ -138,19 +184,6 @@ export interface RoomMember {
     userId: string;
     role: 'owner' | 'editor';
 }
-export type IAesKey = string;
-export type SyncMachinEvent = {
-    type: string;
-    data: any;
-};
-export interface IpfsUploadResponse {
-    ipfsUrl: string;
-    ipfsHash: string;
-    ipfsStorage: string;
-    cachedUrl: string;
-    fileSize: number;
-    mimetype: string;
-}
 export interface IAuthArgs {
     collaborationToken: string;
     documentId: string;

package/dist/package/sync-local/useSyncManager.d.ts

@@ -0,0 +1,11 @@
+import { SyncManagerConfig, CollabConnectionConfig, CollabState } from './types';
+
+export declare const useSyncManager: (config: SyncManagerConfig) => {
+    state: CollabState;
+    connect: (connectConfig: CollabConnectionConfig) => void;
+    disconnect: () => void;
+    terminateSession: () => void;
+    isReady: boolean;
+    awareness: import('y-protocols/awareness.js').Awareness | null;
+    hasCollabContentInitialised: boolean;
+};

package/dist/package/sync-local/utils/createAwarenessUpdateHandler.d.ts

@@ -1,8 +1,8 @@
 import { Awareness } from 'y-protocols/awareness';
-import { SyncMachineContext } from '../types';
+import { SocketClient } from '../socketClient';
 
-export declare const createAwarenessUpdateHandler: (awareness: Awareness, context: SyncMachineContext) => ({ added, updated, removed, }: {
+export declare const createAwarenessUpdateHandler: (awareness: Awareness, socketClient: SocketClient, roomKey: string) => ({ added, updated, removed, }: {
     added: number[];
     updated: number[];
     removed: number[];
-}) => void;
+}, origin: any) => void;

package/dist/package/types.d.ts

@@ -4,7 +4,9 @@ import { EditorProps } from '@tiptap/pm/view';
 import { Editor } from '@tiptap/react';
 import { default as React, SetStateAction } from 'react';
 import { IComment } from './extensions/comment';
+import { CollaborationProps } from './sync-local/types';
 
+export type { CollaborationProps, CollabConnectionConfig, CollabSessionMeta, CollabServices, CollabCallbacks, CollabState, CollabError, CollabErrorCode, CollabStatus, } from './sync-local/types';
 export declare const DdocEditorProps: EditorProps;
 export interface IDocCollabUsers {
     clientId: number;
@@ -113,7 +115,7 @@ export interface DdocProps extends CommentAccountProps {
     extensions?: Record<string, Extension | any>;
     selectedTags?: TagType[];
     setSelectedTags?: React.Dispatch<SetStateAction<TagType[]>>;
-    enableCollaboration?: boolean | undefined;
+    collaboration?: CollaborationProps;
     setIsCommentSectionOpen?: React.Dispatch<SetStateAction<boolean>>;
     inlineCommentData?: InlineCommentData;
     setInlineCommentData?: React.Dispatch<React.SetStateAction<InlineCommentData>>;
@@ -124,7 +126,6 @@ export interface DdocProps extends CommentAccountProps {
     setIsNavbarVisible: React.Dispatch<SetStateAction<boolean>>;
     editorCanvasClassNames?: string;
     isCommentSectionOpen?: boolean;
-    collaborationId?: string;
     isPreviewMode: boolean;
     ensResolutionUrl?: string;
     ipfsImageUploadFn?: (file: File) => Promise<IpfsImageUploadResponse>;
@@ -175,24 +176,11 @@ export interface DdocProps extends CommentAccountProps {
     activeModel?: CustomModel;
     maxTokens?: number;
     isAIAgentEnabled?: boolean;
-    collaborationKey?: CryptoKey | null;
-    collaborationKeyPair?: {
-        publicKey: string;
-        privateKey: string;
-    };
-    collabConfig?: ICollaborationConfig;
     /**
      * Document styling configuration
      * @description Customize the appearance of the document editor
      */
     documentStyling?: DocumentStyling;
-    onCollaborationConnectCallback?: (response: any) => void;
-    onCollaborationCommit?: (file: File) => Promise<string>;
-    onFetchCommitContent?: (cid: string) => Promise<any>;
-    onCollabSessionTermination?: () => void;
-    onUnMergedUpdates?: (state: boolean) => void;
-    onCollabError?: (error: any) => void;
-    isExistingCollabSession?: boolean;
     /**
      * Callback when IndexedDB initialization fails
      * @description Called when the IndexedDB persistence provider fails to initialize (e.g., private browsing, quota exceeded, corrupted DB). The editor will continue to function without local persistence.
@@ -229,19 +217,3 @@ export interface IpfsImageFetchPayload {
     mimeType: string;
     authTag: string;
 }
-export interface ICollaborationConfig {
-    roomKey: string;
-    collaborationId: string;
-    username: string;
-    isOwner: boolean;
-    ownerEdSecret?: string;
-    contractAddress?: string;
-    ownerAddress?: string;
-    wsUrl: string;
-    isEns?: boolean;
-    roomInfo?: {
-        documentTitle: string;
-        portalAddress: string;
-        commentKey: string;
-    };
-}