@nice2dev/ui-communication 1.0.2

package/dist/types/communicationTypes.d.ts

@@ -0,0 +1,697 @@
+import { CSSProperties, ReactNode } from 'react';
+
+export type NiceAccessMode = 'read' | 'write' | 'none';
+export interface NiceCommunicationBaseProps {
+    className?: string;
+    style?: CSSProperties;
+    id?: string;
+    title?: string;
+    'data-testid'?: string;
+    accessMode?: NiceAccessMode;
+}
+export type PresenceStatus = 'online' | 'away' | 'busy' | 'dnd' | 'offline' | 'invisible' | 'unknown';
+export interface PresenceInfo {
+    status: PresenceStatus;
+    statusMessage?: string;
+    lastSeenAt?: Date;
+}
+export type UserRole = 'owner' | 'admin' | 'member' | 'guest' | 'bot';
+export interface CommunicationUser {
+    id: string;
+    name: string;
+    displayName?: string;
+    avatarUrl?: string;
+    email?: string;
+    presence: PresenceInfo;
+    role?: UserRole;
+    timezone?: string;
+    isBot?: boolean;
+    phone?: string;
+}
+export interface TeamMember extends CommunicationUser {
+    teamRole: 'owner' | 'admin' | 'member' | 'guest';
+    joinedAt?: Date;
+}
+export type MessageContentType = 'text' | 'rich' | 'markdown' | 'file' | 'image' | 'video' | 'audio' | 'code' | 'system' | 'call-event' | 'meeting-invite' | 'poll' | 'gif' | 'sticker';
+export type MessageStatus = 'sending' | 'sent' | 'delivered' | 'read' | 'failed';
+export interface MessageReaction {
+    emoji: string;
+    count: number;
+    userIds: string[];
+    mine?: boolean;
+}
+export interface MessageAttachment {
+    id: string;
+    type: 'file' | 'image' | 'video' | 'audio';
+    name: string;
+    url: string;
+    size: number;
+    mimeType: string;
+    thumbnailUrl?: string;
+    width?: number;
+    height?: number;
+    duration?: number;
+}
+export interface MessageMention {
+    userId?: string;
+    channelId?: string;
+    teamId?: string;
+    type: 'user' | 'channel' | 'team' | 'everyone' | 'here';
+    displayText: string;
+    offset: number;
+    length: number;
+}
+export interface PollOption {
+    id: string;
+    text: string;
+    votes: number;
+    voterIds: string[];
+}
+export interface PollData {
+    question: string;
+    options: PollOption[];
+    allowMultiple: boolean;
+    isAnonymous: boolean;
+    expiresAt?: Date;
+    isClosed: boolean;
+}
+export interface CodeSnippet {
+    language: string;
+    code: string;
+    filename?: string;
+}
+export interface ChatMessage {
+    id: string;
+    conversationId: string;
+    channelId?: string;
+    authorId: string;
+    content: string;
+    contentType: MessageContentType;
+    timestamp: Date;
+    editedAt?: Date;
+    status: MessageStatus;
+    reactions?: MessageReaction[];
+    attachments?: MessageAttachment[];
+    mentions?: MessageMention[];
+    thread?: ChatMessage[];
+    threadCount?: number;
+    replyToId?: string;
+    replyTo?: Pick<ChatMessage, 'id' | 'authorId' | 'content'>;
+    isPinned?: boolean;
+    isForwarded?: boolean;
+    isDeleted?: boolean;
+    pollData?: PollData;
+    codeSnippet?: CodeSnippet;
+    callEventData?: CallEventData;
+    metadata?: Record<string, unknown>;
+}
+export interface CallEventData {
+    callId: string;
+    type: 'started' | 'ended' | 'missed' | 'declined';
+    callType: 'audio' | 'video';
+    duration?: number;
+    participantIds: string[];
+}
+export type ConversationType = 'dm' | 'group' | 'channel' | 'meeting';
+export interface Conversation {
+    id: string;
+    type: ConversationType;
+    name?: string;
+    avatarUrl?: string;
+    description?: string;
+    participantIds: string[];
+    lastMessage?: ChatMessage;
+    unreadCount: number;
+    mentionCount: number;
+    isPinned: boolean;
+    isMuted: boolean;
+    isArchived: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, unknown>;
+}
+export type ChannelType = 'general' | 'private' | 'shared' | 'announcement' | 'info';
+export interface Channel {
+    id: string;
+    teamId: string;
+    name: string;
+    description?: string;
+    type: ChannelType;
+    isPinned: boolean;
+    isMuted: boolean;
+    isArchived: boolean;
+    isPrivate: boolean;
+    unreadCount: number;
+    mentionCount: number;
+    memberCount: number;
+    createdAt: Date;
+    topicSetBy?: string;
+    topic?: string;
+}
+export interface Team {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+    description?: string;
+    channels: Channel[];
+    members: TeamMember[];
+    ownerId: string;
+    isPrivate: boolean;
+    createdAt: Date;
+}
+export type CallStatus = 'idle' | 'ringing' | 'connecting' | 'active' | 'on-hold' | 'ended' | 'missed' | 'declined';
+export type CallType = 'audio' | 'video';
+export interface CallParticipant {
+    user: CommunicationUser;
+    isMuted: boolean;
+    isCameraOff: boolean;
+    isScreenSharing: boolean;
+    isSpeaking: boolean;
+    isHandRaised: boolean;
+    stream?: MediaStream;
+    screenStream?: MediaStream;
+    connectionQuality: 'excellent' | 'good' | 'fair' | 'poor' | 'none';
+}
+export interface CallSession {
+    id: string;
+    type: CallType;
+    conversationId?: string;
+    channelId?: string;
+    participants: CallParticipant[];
+    status: CallStatus;
+    startedAt?: Date;
+    endedAt?: Date;
+    duration?: number;
+    isRecording: boolean;
+    isTranscribing: boolean;
+    pinnedParticipantId?: string;
+    layout: 'grid' | 'spotlight' | 'sidebar';
+}
+export interface IncomingCall {
+    callId: string;
+    callType: CallType;
+    caller: CommunicationUser;
+    conversationId?: string;
+    startedAt: Date;
+}
+export interface Meeting {
+    id: string;
+    title: string;
+    description?: string;
+    organizerId: string;
+    participantIds: string[];
+    scheduledStart: Date;
+    scheduledEnd: Date;
+    joinUrl?: string;
+    isRecurring?: boolean;
+    channelId?: string;
+    teamId?: string;
+}
+export interface IceServerConfig {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+export interface RTCTransportConfig {
+    iceServers?: IceServerConfig[];
+    signalingUrl?: string;
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    maxBitrate?: {
+        audio?: number;
+        video?: number;
+        screen?: number;
+    };
+}
+export type TransportType = 'webrtc' | 'sfu' | 'mock' | 'custom';
+export type CommunicationMode = 'bubble' | 'chat' | 'messenger' | 'workspace' | 'call' | 'conference' | 'whiteboard';
+export interface CommunicationCallbacks {
+    onSendMessage?: (conversationId: string, content: string, contentType?: MessageContentType, attachments?: File[]) => void | Promise<void>;
+    onEditMessage?: (messageId: string, content: string) => void | Promise<void>;
+    onDeleteMessage?: (messageId: string) => void | Promise<void>;
+    onReactToMessage?: (messageId: string, emoji: string) => void | Promise<void>;
+    onPinMessage?: (messageId: string) => void | Promise<void>;
+    onStartCall?: (participantIds: string[], type: CallType) => void | Promise<void>;
+    onAcceptCall?: (callId: string) => void | Promise<void>;
+    onDeclineCall?: (callId: string) => void | Promise<void>;
+    onEndCall?: (callId: string) => void | Promise<void>;
+    onMuteAudio?: (muted: boolean) => void;
+    onMuteVideo?: (muted: boolean) => void;
+    onStartScreenShare?: () => void | Promise<void>;
+    onStopScreenShare?: () => void;
+    onRaiseHand?: (raised: boolean) => void;
+    onCreateConversation?: (participantIds: string[], type: ConversationType, name?: string) => void | Promise<void>;
+    onMarkAsRead?: (conversationId: string) => void | Promise<void>;
+    onLoadMoreMessages?: (conversationId: string, beforeId: string) => void | Promise<void>;
+    onOpenMeeting?: (meetingId: string) => void;
+    onJoinMeeting?: (meetingId: string) => void | Promise<void>;
+    onModeChange?: (mode: CommunicationMode) => void;
+}
+export interface NiceCommunicationProps extends NiceCommunicationBaseProps, CommunicationCallbacks {
+    mode: CommunicationMode;
+    currentUser: CommunicationUser;
+    users: CommunicationUser[];
+    conversations?: Conversation[];
+    messages?: Record<string, ChatMessage[]>;
+    activeConversationId?: string;
+    teams?: Team[];
+    channels?: Channel[];
+    activeChannelId?: string;
+    activeTeamId?: string;
+    meetings?: Meeting[];
+    activeCall?: CallSession;
+    incomingCall?: IncomingCall;
+    transport?: TransportType;
+    rtcConfig?: RTCTransportConfig;
+    bubblePosition?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    bubbleLabel?: string;
+    placeholder?: string;
+    maxMessageLength?: number;
+    showTypingIndicators?: boolean;
+    enableReactions?: boolean;
+    enableThreads?: boolean;
+    enableAttachments?: boolean;
+    enablePolls?: boolean;
+    enableCodeSnippets?: boolean;
+    enableScreenSharing?: boolean;
+    enableRecording?: boolean;
+    enableTranscription?: boolean;
+    enableMeetings?: boolean;
+    enableGifs?: boolean;
+    enableWhiteboard?: boolean;
+    storageConfig?: StorageConfig;
+    encryptionConfig?: EncryptionConfig;
+    theme?: 'light' | 'dark' | 'auto';
+    locale?: string;
+}
+export interface NicePresenceIndicatorProps extends NiceCommunicationBaseProps {
+    status: PresenceStatus;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    showLabel?: boolean;
+    showTooltip?: boolean;
+}
+export interface NiceChatWindowProps extends NiceCommunicationBaseProps, CommunicationCallbacks {
+    conversation: Conversation;
+    messages: ChatMessage[];
+    users: CommunicationUser[];
+    currentUser: CommunicationUser;
+    isLoading?: boolean;
+    hasMore?: boolean;
+    showHeader?: boolean;
+    showUserAvatars?: boolean;
+    enableReactions?: boolean;
+    enableThreads?: boolean;
+    enableAttachments?: boolean;
+    enablePolls?: boolean;
+    placeholder?: string;
+    maxMessageLength?: number;
+}
+export interface NiceMessengerProps extends NiceCommunicationBaseProps, CommunicationCallbacks {
+    conversations: Conversation[];
+    messages: Record<string, ChatMessage[]>;
+    users: CommunicationUser[];
+    currentUser: CommunicationUser;
+    activeConversationId?: string;
+    teams?: Team[];
+    enableGroupConversations?: boolean;
+    showPresence?: boolean;
+    enableSearch?: boolean;
+}
+export interface NiceCallScreenProps extends NiceCommunicationBaseProps, CommunicationCallbacks {
+    session: CallSession;
+    currentUser: CommunicationUser;
+    localStream?: MediaStream;
+    enableScreenSharing?: boolean;
+    enableRecording?: boolean;
+}
+export interface NiceVideoConferenceProps extends NiceCommunicationBaseProps, CommunicationCallbacks {
+    session: CallSession;
+    currentUser: CommunicationUser;
+    localStream?: MediaStream;
+    enableScreenSharing?: boolean;
+    enableRecording?: boolean;
+    enableTranscription?: boolean;
+    enableRaiseHand?: boolean;
+    maxGridCols?: number;
+}
+export interface NiceChannelViewProps extends NiceCommunicationBaseProps, CommunicationCallbacks {
+    channel: Channel;
+    messages: ChatMessage[];
+    users: CommunicationUser[];
+    currentUser: CommunicationUser;
+    team?: Team;
+    isLoading?: boolean;
+    hasMore?: boolean;
+    enableThreads?: boolean;
+    enableReactions?: boolean;
+    enableAttachments?: boolean;
+    enablePolls?: boolean;
+}
+export interface NiceTeamsWorkspaceProps extends NiceCommunicationBaseProps, CommunicationCallbacks {
+    currentUser: CommunicationUser;
+    users: CommunicationUser[];
+    teams: Team[];
+    conversations: Conversation[];
+    messages: Record<string, ChatMessage[]>;
+    activeCall?: CallSession;
+    incomingCall?: IncomingCall;
+    meetings?: Meeting[];
+    transport?: TransportType;
+    rtcConfig?: RTCTransportConfig;
+    enableCalls?: boolean;
+    enableMeetings?: boolean;
+    enableScreenSharing?: boolean;
+    enableWhiteboard?: boolean;
+    storageConfig?: StorageConfig;
+    encryptionConfig?: EncryptionConfig;
+}
+export type EncryptionAlgorithm = 'none' | 'AES-GCM-256' | 'AES-GCM-128' | 'ChaCha20-Poly1305' | 'E2E-ECDH-P384';
+export type EncryptionScope = 'messages' | 'attachments' | 'whiteboard' | 'recordings' | 'documents' | 'calls' | 'presence' | 'all';
+export interface EncryptionScopeConfig {
+    scope: EncryptionScope;
+    algorithm: EncryptionAlgorithm;
+    enabled: boolean;
+}
+export interface EncryptionConfig {
+    /** Master switch — if false nothing is encrypted */
+    enabled: boolean;
+    /** Default algorithm for unspecified scopes */
+    defaultAlgorithm: EncryptionAlgorithm;
+    /** Per-scope overrides */
+    scopeOverrides?: EncryptionScopeConfig[];
+    /** Key-exchange endpoint for E2E-ECDH */
+    keyExchangeUrl?: string;
+    /** Externally provided symmetric key (base64-encoded raw bytes) */
+    keyMaterial?: string;
+    /** Show lock icon in UI when encryption is active */
+    showIndicator?: boolean;
+}
+export type RetentionUnit = 'days' | 'weeks' | 'months' | 'years' | 'forever';
+export interface RetentionPeriod {
+    value: number;
+    unit: RetentionUnit;
+}
+export type RetentionDataType = 'messages' | 'attachments' | 'whiteboard-snapshots' | 'recordings' | 'transcripts' | 'documents' | 'call-logs' | 'audit-logs';
+export interface RetentionRule {
+    dataType: RetentionDataType;
+    /** How long data is active / searchable */
+    activePeriod: RetentionPeriod;
+    /** Grace period in archive before final deletion (undefined = no archive) */
+    archivePeriod?: RetentionPeriod;
+    /** Permanently delete data after the archive period */
+    deleteAfterArchive: boolean;
+    /** Users can delete their own records */
+    userCanDelete: boolean;
+    /** Freeze deletion for legal-hold investigations */
+    legalHoldEnabled?: boolean;
+}
+export interface IStorageAdapter {
+    save(key: string, data: unknown, expiresAt?: Date): Promise<void>;
+    load(key: string): Promise<unknown>;
+    delete(key: string): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+    clear(prefix?: string): Promise<void>;
+}
+export interface StorageConfig {
+    provider: 'indexeddb' | 'localstorage' | 'server' | 'custom';
+    /** Base URL for server provider */
+    serverUrl?: string;
+    authToken?: string;
+    retentionRules: RetentionRule[];
+    encryption?: EncryptionConfig;
+    /** Total quota in bytes (0 = unlimited) */
+    quota?: number;
+    customAdapter?: IStorageAdapter;
+}
+export type RecordingState = 'idle' | 'recording' | 'paused' | 'processing' | 'ready' | 'failed';
+export interface TranscriptWord {
+    word: string;
+    startMs: number;
+    endMs: number;
+    confidence: number;
+}
+export interface TranscriptSegment {
+    id: string;
+    speakerId: string;
+    speakerName: string;
+    text: string;
+    startMs: number;
+    endMs: number;
+    confidence: number;
+    words?: TranscriptWord[];
+}
+export interface RecordingSession {
+    id: string;
+    sessionType: 'call' | 'meeting' | 'whiteboard' | 'screen';
+    callId?: string;
+    meetingId?: string;
+    whiteboardId?: string;
+    startedAt: Date;
+    endedAt?: Date;
+    durationMs?: number;
+    state: RecordingState;
+    blob?: Blob;
+    url?: string;
+    size?: number;
+    mimeType: string;
+    transcript?: TranscriptSegment[];
+    participants: string[];
+    title?: string;
+}
+export type WhiteboardToolType = 'pen' | 'highlighter' | 'eraser' | 'select' | 'line' | 'arrow' | 'rect' | 'ellipse' | 'triangle' | 'text' | 'sticky' | 'image' | 'laser' | 'frame';
+export type WhiteboardObjectType = 'stroke' | 'shape' | 'text' | 'sticky' | 'image' | 'frame' | 'connector';
+export interface WhiteboardPoint {
+    x: number;
+    y: number;
+    pressure?: number;
+}
+export interface WhiteboardBaseObject {
+    id: string;
+    type: WhiteboardObjectType;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    zIndex: number;
+    layerId?: string;
+    locked: boolean;
+    visible: boolean;
+    createdBy: string;
+    createdAt: Date;
+    updatedBy?: string;
+    updatedAt?: Date;
+    metadata?: Record<string, unknown>;
+}
+export interface WhiteboardStroke extends WhiteboardBaseObject {
+    type: 'stroke';
+    points: WhiteboardPoint[];
+    color: string;
+    strokeWidth: number;
+    opacity: number;
+    tool: 'pen' | 'highlighter';
+}
+export interface WhiteboardShape extends WhiteboardBaseObject {
+    type: 'shape';
+    shape: 'rect' | 'ellipse' | 'triangle' | 'diamond' | 'hexagon' | 'star';
+    fillColor?: string;
+    strokeColor: string;
+    strokeWidth: number;
+    opacity: number;
+}
+export interface WhiteboardTextObject extends WhiteboardBaseObject {
+    type: 'text';
+    text: string;
+    fontSize: number;
+    fontFamily: string;
+    fontWeight: 'normal' | 'bold';
+    fontStyle: 'normal' | 'italic';
+    textAlign: 'left' | 'center' | 'right';
+    color: string;
+    backgroundColor?: string;
+}
+export interface WhiteboardStickyNote extends WhiteboardBaseObject {
+    type: 'sticky';
+    text: string;
+    backgroundColor: string;
+    textColor: string;
+    fontSize: number;
+    authorId: string;
+}
+export interface WhiteboardImage extends WhiteboardBaseObject {
+    type: 'image';
+    url: string;
+    dataUrl?: string;
+    originalWidth: number;
+    originalHeight: number;
+}
+export interface WhiteboardFrame extends WhiteboardBaseObject {
+    type: 'frame';
+    name: string;
+    backgroundColor?: string;
+    borderColor?: string;
+    childIds: string[];
+}
+export interface WhiteboardConnector extends WhiteboardBaseObject {
+    type: 'connector';
+    points: WhiteboardPoint[];
+    fromObjectId?: string;
+    toObjectId?: string;
+    strokeColor: string;
+    strokeWidth: number;
+    arrowStart: 'none' | 'arrow' | 'circle' | 'diamond';
+    arrowEnd: 'none' | 'arrow' | 'circle' | 'diamond';
+    label?: string;
+    curved: boolean;
+}
+export type WhiteboardObject = WhiteboardStroke | WhiteboardShape | WhiteboardTextObject | WhiteboardStickyNote | WhiteboardImage | WhiteboardFrame | WhiteboardConnector;
+export interface WhiteboardLayer {
+    id: string;
+    name: string;
+    visible: boolean;
+    locked: boolean;
+    objectIds: string[];
+}
+export interface WhiteboardCollaborator {
+    user: CommunicationUser;
+    cursorX: number;
+    cursorY: number;
+    color: string;
+    selectedObjectIds: string[];
+    activeTool: WhiteboardToolType;
+    lastSeenAt: Date;
+}
+export interface WhiteboardViewport {
+    x: number;
+    y: number;
+    scale: number;
+}
+export interface WhiteboardSession {
+    id: string;
+    title: string;
+    channelId?: string;
+    conversationId?: string;
+    meetingId?: string;
+    objects: Record<string, WhiteboardObject>;
+    layers: WhiteboardLayer[];
+    collaborators: Record<string, WhiteboardCollaborator>;
+    viewport: WhiteboardViewport;
+    width: number;
+    height: number;
+    backgroundColor: string;
+    gridEnabled: boolean;
+    gridSize: number;
+    snapEnabled: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    ownerId: string;
+    permissions: 'view' | 'comment' | 'edit';
+}
+export type WhiteboardOpType = 'object:add' | 'object:update' | 'object:delete' | 'object:move' | 'cursor:move' | 'selection:change' | 'layer:add' | 'layer:update' | 'layer:delete' | 'viewport:sync' | 'undo' | 'redo';
+export interface WhiteboardOperation {
+    id: string;
+    sessionId: string;
+    type: WhiteboardOpType;
+    userId: string;
+    timestamp: Date;
+    payload: unknown;
+    vectorClock?: Record<string, number>;
+}
+export interface NiceWhiteboardProps extends NiceCommunicationBaseProps {
+    session: WhiteboardSession;
+    currentUser: CommunicationUser;
+    /** Called whenever the whiteboard emits an operation to broadcast */
+    onOperation?: (op: WhiteboardOperation) => void;
+    /** Remote operations to apply (from other participants) */
+    remoteOperations?: WhiteboardOperation[];
+    readonly?: boolean;
+    enableLayers?: boolean;
+    enableExport?: boolean;
+    enableImport?: boolean;
+    enableTemplates?: boolean;
+    /** Show cursor laser pointer for presentations */
+    enableLaserPointer?: boolean;
+    /** Integration: render a VectorEditor pane */
+    enableVectorEditor?: boolean;
+    /** Integration: render a DiagramEditor pane */
+    enableDiagramEditor?: boolean;
+    onExport?: (format: 'png' | 'svg' | 'json' | 'pdf', data: string | Blob) => void;
+    onSessionUpdate?: (session: WhiteboardSession) => void;
+    storageConfig?: StorageConfig;
+}
+export interface NiceStorageSettingsProps extends NiceCommunicationBaseProps {
+    storageConfig: StorageConfig;
+    encryptionConfig?: EncryptionConfig;
+    onStorageConfigChange?: (config: StorageConfig) => void;
+    onEncryptionConfigChange?: (config: EncryptionConfig) => void;
+    /** In bytes — for quota usage display */
+    currentUsageBytes?: number;
+    showEncryption?: boolean;
+    showRetention?: boolean;
+    showQuota?: boolean;
+}
+export interface NiceRecordingPanelProps extends NiceCommunicationBaseProps {
+    recordings?: RecordingSession[];
+    activeRecordingId?: string;
+    activeRecording?: RecordingSession;
+    /** Session type for new recordings */
+    sessionType?: RecordingSession['sessionType'];
+    onRecordingStart?: () => void;
+    onRecordingStop?: () => void;
+    onRecordingPause?: () => void;
+    onRecordingResume?: () => void;
+    onRecordingDelete?: (recordingId: string) => void;
+    onRecordingDownload?: (recordingId: string) => void;
+    /** @deprecated Use onRecordingStart */ onStartRecording?: (sessionType: RecordingSession['sessionType'], title?: string) => void;
+    /** @deprecated Use onRecordingStop  */ onStopRecording?: (recordingId: string) => void;
+    /** @deprecated Use onRecordingPause */ onPauseRecording?: (recordingId: string) => void;
+    /** @deprecated */ onResumeRecording?: (recordingId: string) => void;
+    /** @deprecated */ onDeleteRecording?: (recordingId: string) => void;
+    /** @deprecated */ onDownloadRecording?: (recordingId: string) => void;
+    onPlayRecording?: (recordingId: string) => void;
+    onViewTranscript?: (recordingId: string) => void;
+    canRecord?: boolean;
+    maxRecordingDurationMs?: number;
+    storageConfig?: StorageConfig;
+}
+export type CollaborativeEditorType = 'vector' | 'pixel' | 'diagram' | 'document' | 'whiteboard';
+export interface CollaborativeEditorParticipant {
+    user: CommunicationUser;
+    color: string;
+    /** Cursor X in editor-local coordinates */
+    cursorX?: number;
+    /** Cursor Y in editor-local coordinates */
+    cursorY?: number;
+    cursorPosition?: unknown;
+    selection?: unknown;
+    /** Whether the participant is actively editing vs. just viewing */
+    isActive?: boolean;
+    /** Human-readable region label on the canvas (e.g. "Layer 2") */
+    editingRegion?: string;
+    lastSeenAt: Date;
+}
+export interface NiceCollaborativeEditorProps extends NiceCommunicationBaseProps {
+    editorType: CollaborativeEditorType;
+    sessionId: string;
+    currentUser: CommunicationUser;
+    participants?: CollaborativeEditorParticipant[];
+    /** Called when local user makes an edit — broadcast payload to peers */
+    onOperation?: (op: unknown) => void;
+    /** Remote operations to apply */
+    remoteOperations?: unknown[];
+    isReadOnly?: boolean;
+    showParticipants?: boolean;
+    /** Whether to render remote cursor overlays */
+    showCursors?: boolean;
+    /** Number of operations queued for remote broadcast */
+    pendingOperations?: number;
+    /** Number of unresolved merge conflicts */
+    conflictCount?: number;
+    onParticipantJoin?: (userId: string) => void;
+    onParticipantLeave?: (userId: string) => void;
+    /** Called when local cursor moves (x, y in editor coords) */
+    onCursorMove?: (x: number, y: number) => void;
+    onParticipantClick?: (userId: string) => void;
+    storageConfig?: StorageConfig;
+    /** Editor element to render inside the collaboration overlay */
+    children?: ReactNode;
+}