captify 0.1.18 → 0.1.19

package/dist/collaboration/collaboration.interfaces.d.ts

@@ -0,0 +1,1271 @@
+/**
+ * TypeScript interfaces for Collaboration Documents module
+ *
+ * Only includes interfaces currently in use by the service layer.
+ * Additional interfaces for hooks, components, and other services
+ * should be added when those features are implemented.
+ */
+import type { DocumentFilter, ViewMode } from "./collaboration.constants";
+import type { CollabDocument } from "./collaboration.schemas";
+import type { CollabDocumentsTableSchema } from "../db/schemas/collab-documents.schema";
+import type { PromptFileAttachment } from "../shared/shared.interfaces";
+import type { DynamoDbService } from "../shared/services/dynamodb";
+import type { Logger } from "../shared/services/logger";
+import type { UserAwsCredentials } from "../shared/services";
+import type { UIMessage } from "@ai-sdk/react";
+/**
+ * Sort option configuration for document list
+ */
+export interface SortOption {
+    label: string;
+    field: "updatedAt" | "createdAt" | "title" | "wordCount";
+    direction: "asc" | "desc";
+}
+/**
+ * Dependencies for CollaborationService
+ */
+export interface CollaborationServiceDeps {
+    logger?: Logger;
+    db?: DynamoDbService<CollabDocumentsTableSchema>;
+}
+/**
+ * Parameters for getting a single document
+ */
+export interface GetDocumentParams {
+    documentId: string;
+    tenantId: string;
+    userId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for listing documents
+ */
+export interface ListDocumentsParams {
+    tenantId: string;
+    userId: string;
+    filter?: DocumentFilter;
+    search?: string;
+    limit?: number;
+    nextToken?: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for creating a new document
+ */
+export interface CreateDocumentParams {
+    tenantId: string;
+    title: string;
+    ownerId: string;
+    ownerName: string;
+    ownerEmail: string;
+    content?: Uint8Array;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for updating a document
+ */
+export interface UpdateDocumentParams {
+    documentId: string;
+    tenantId: string;
+    userId: string;
+    updates: {
+        title?: string;
+        content?: Uint8Array;
+        contentVector?: Uint8Array;
+        wordCount?: number;
+        previewSnippet?: string;
+    };
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for deleting a document (soft delete)
+ */
+export interface DeleteDocumentParams {
+    documentId: string;
+    tenantId: string;
+    userId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for restoring a trashed document
+ */
+export interface RestoreDocumentParams {
+    documentId: string;
+    tenantId: string;
+    userId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for permanently deleting a document
+ */
+export interface PermanentDeleteDocumentParams {
+    documentId: string;
+    tenantId: string;
+    userId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Response for document list
+ */
+export interface ListDocumentsResponse {
+    documents: CollabDocument[];
+    nextToken?: string;
+    total: number;
+}
+/**
+ * Options for useDocument hook
+ */
+export interface UseDocumentOptions {
+    /** Document ID to fetch */
+    documentId: string;
+    /** Whether to enable the query (default: true) */
+    enabled?: boolean;
+}
+export interface DocumentUpdateMutationInput {
+    data: import("./collaboration.schemas").UpdateDocumentBody;
+    showToast?: boolean;
+}
+export interface DocumentUpdateOptions {
+    showToast?: boolean;
+}
+/**
+ * Options for useDocuments hook
+ */
+export interface UseDocumentsOptions {
+    /** Filter type (all, my-documents, shared-with-me, recent, trashed) */
+    filter?: DocumentFilter;
+    /** Search query string */
+    search?: string;
+    /** Maximum number of documents to fetch */
+    limit?: number;
+    /** Pagination token */
+    nextToken?: string;
+    /** Whether to enable the query (default: true) */
+    enabled?: boolean;
+}
+export type InlineCommentFileAttachment = PromptFileAttachment;
+export interface CollaborationDeleteTarget {
+    id: string;
+    title: string;
+    permanent: boolean;
+}
+export interface UseCollaborationListParamsReturn {
+    filter: DocumentFilter;
+    search: string;
+    viewMode: ViewMode;
+    handleFilterChange: (newFilter: DocumentFilter) => void;
+    handleSearchChange: (newSearch: string) => void;
+    handleViewModeChange: (mode: ViewMode) => void;
+}
+export interface CollaborationGenerateDocumentInput {
+    description: string;
+    files?: PromptFileAttachment[];
+}
+export interface UseCollaborationDocumentActionsReturn {
+    documents: CollabDocument[];
+    isLoading: boolean;
+    isError: boolean;
+    error: unknown;
+    refetch: () => Promise<unknown>;
+    isCreating: boolean;
+    isDeleting: boolean;
+    isPermanentDeleting: boolean;
+    deleteTarget: CollaborationDeleteTarget | null;
+    clearDeleteTarget: () => void;
+    handleCreateDocument: () => Promise<void>;
+    handleGenerateDocument: (input: CollaborationGenerateDocumentInput) => Promise<void>;
+    handleOpenDocument: (doc: CollabDocument) => void;
+    handleDeleteDocument: (doc: CollabDocument) => void;
+    handleRestoreDocument: (doc: CollabDocument) => Promise<void>;
+    handlePermanentDelete: (doc: CollabDocument) => void;
+    handleConfirmDelete: () => Promise<void>;
+}
+export interface UseCollaborationDocumentActionsProps {
+    filter: DocumentFilter;
+    search: string;
+}
+export interface DocumentGenerationInput {
+    description: string;
+    files?: PromptFileAttachment[];
+}
+export interface StoredDocumentGenerationInput {
+    description: string;
+    files?: PromptFileAttachment[];
+}
+export interface DocumentGenerationStreamResult {
+    generateStream: (input: DocumentGenerationInput) => Promise<void>;
+    cancel: () => void;
+    isGenerating: boolean;
+    error: Error | null;
+}
+export interface UseDocumentGenerationStreamOptions {
+    documentId: string;
+    ydoc: import("yjs").Doc;
+    onTitleChange: (title: string) => void;
+    saveNow: () => Promise<void>;
+    onChunk?: () => void;
+}
+export interface DocumentGenerationStreamParams {
+    documentId: string;
+    prompt: string;
+    files?: PromptFileAttachment[];
+    ydoc: import("yjs").Doc;
+    onTitleChange: (title: string) => void;
+    onChunk?: () => void;
+    signal: AbortSignal;
+}
+export interface UseAutoDocumentGenerationOptions {
+    documentId: string;
+    ydoc: import("yjs").Doc;
+    onTitleChange: (title: string) => void;
+    saveNow: () => Promise<void>;
+    onChunk?: () => void;
+}
+export interface UseAutoDocumentGenerationReturn {
+    isGenerating: boolean;
+}
+export interface DocumentGenerationModelParams {
+    tenantId: string;
+    userCredentials?: UserAwsCredentials;
+}
+export interface DocumentGenerationAccessParams {
+    tenantId: string;
+    userId: string;
+    documentId: string;
+    userCredentials?: UserAwsCredentials;
+}
+export interface StreamContentGenerationParams {
+    tenantId: string;
+    userId: string;
+    documentId: string;
+    prompt: string;
+    contextMode: import("./collaboration.constants").AiContextMode;
+    selectionText?: string;
+    documentContent?: string;
+    files?: InlineCommentFileAttachment[];
+    modelId?: string;
+    agentId?: string;
+    messages: UIMessage[];
+    userCredentials?: UserAwsCredentials;
+}
+export interface GenerateDocumentParams {
+    tenantId: string;
+    userId: string;
+    documentId: string;
+    prompt: string;
+    userCredentials?: UserAwsCredentials;
+}
+export interface DocumentGenerationParsedResult {
+    title: string;
+    content: string;
+}
+export type DocumentGenerationMessageContent = Array<{
+    type: "text";
+    text: string;
+} | {
+    type: "file";
+    data: string;
+    mediaType: string;
+}>;
+/**
+ * User information for yjs awareness (presence)
+ */
+export interface AwarenessUser {
+    /** User ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Cursor/highlight color (hex or hsl) */
+    color: string;
+    /** Optional avatar URL */
+    avatarUrl?: string;
+}
+/**
+ * Connection status for yjs provider
+ */
+export type ConnectionStatus = "connecting" | "connected" | "disconnected";
+/**
+ * Auto-save status for tracking database persistence
+ */
+export type AutoSaveStatus = "idle" | "pending" | "saving" | "saved" | "error";
+/**
+ * Context value for YjsProvider
+ */
+export interface YjsContextValue {
+    /** The yjs document for this editing session */
+    ydoc: import("yjs").Doc;
+    /** The yjs awareness instance for presence */
+    awareness: import("y-websocket").WebsocketProvider["awareness"] | null;
+    /** Current connection status */
+    status: ConnectionStatus;
+    /** Whether the document is synced with the server */
+    isSynced: boolean;
+    /** Whether offline persistence is enabled and synced */
+    isOfflineSynced: boolean;
+    /** Force reconnect to the server */
+    reconnect: () => void;
+    /** Auto-save status for database persistence */
+    autoSaveStatus: AutoSaveStatus;
+    /** Timestamp of last successful save to database */
+    lastSavedAt: number | null;
+    /** Manually trigger a save to the database */
+    saveNow: () => Promise<void>;
+}
+/**
+ * Props for YjsProvider component
+ */
+export interface YjsProviderProps {
+    /** Document ID for the yjs room */
+    documentId: string;
+    /** WebSocket server URL */
+    wsUrl?: string;
+    /** User information for awareness (uses AwarenessUser type) */
+    user?: AwarenessUser;
+    /** Enable offline persistence with localStorage (default: true) */
+    enableOffline?: boolean;
+    /** Enable auto-save to database (default: true) */
+    enableAutoSave?: boolean;
+    /** Children components */
+    children: React.ReactNode;
+}
+/**
+ * Props for DocumentHeader component
+ */
+export interface DocumentHeaderProps {
+    /** Document title */
+    title: string;
+    /** Whether the title is being edited */
+    isEditingTitle?: boolean;
+    /** Callback when title changes */
+    onTitleChange?: (title: string) => void;
+    /** Connection status for sync indicator */
+    connectionStatus: ConnectionStatus;
+    /** Whether the document is synced */
+    isSynced: boolean;
+    /** Whether the document can be edited */
+    canEdit?: boolean;
+    /** Whether the user can share the document (admin only) */
+    canShare?: boolean;
+    /** Whether the user can delete the document (owner only) */
+    canDelete?: boolean;
+    /** List of currently connected remote users for avatar display */
+    connectedUsers?: AwarenessUser[];
+    /** Total number of unique users online (including local user) */
+    totalOnlineCount?: number;
+    /** Callback when share button is clicked */
+    onShare?: () => void;
+    /** Callback when save version button is clicked */
+    onSaveVersion?: () => void;
+    /** Whether a version save is in progress */
+    isSavingVersion?: boolean;
+    /** Whether AI generation is in progress */
+    isGenerating?: boolean;
+    /** Callback when delete is clicked */
+    onDelete?: () => void;
+    /** Additional class names */
+    className?: string;
+}
+export interface PresenceIndicatorProps {
+    users: AwarenessUser[];
+    totalCount: number;
+}
+/**
+ * Props for SyncStatus component
+ */
+export interface SyncStatusProps {
+    status: ConnectionStatus;
+    isSynced: boolean;
+}
+/**
+ * Props for DocumentEditor component (markdown mode)
+ */
+export interface DocumentEditorProps {
+    /** Whether the editor is editable */
+    editable?: boolean;
+    /** Additional class names */
+    className?: string;
+    /** Whether to show the toolbar */
+    showToolbar?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Callback when content changes */
+    onUpdate?: (content: string) => void;
+    /** Callback when selection changes */
+    onSelectionChange?: (selectedText: string | undefined) => void;
+    /** Document ID for inline comments */
+    documentId?: string;
+    /** Current user for comments */
+    currentUser?: {
+        id: string;
+        name: string;
+        email?: string;
+        avatarUrl?: string;
+    } | null;
+    /** Inline comment highlights */
+    comments?: InlineCommentHighlight[];
+    /** Comment threads for inline popover */
+    commentThreads?: import("../comments/comments.interfaces").CommentThread[];
+    /** Whether user can comment */
+    canComment?: boolean;
+    /** Users that can be @mentioned */
+    mentionableUsers?: import("../comments/comments.interfaces").MentionableUser[];
+    /** Callback when a comment is clicked */
+    onCommentClick?: (commentId: string) => void;
+    /** ID of the currently focused comment */
+    focusedCommentId?: string;
+    /** Callback to refresh inline comments */
+    onInlineCommentsRefresh?: () => void;
+}
+/**
+ * Inline comment metadata stored on generic comments
+ */
+export interface InlineCommentMetadata {
+    anchorStart: string;
+    anchorEnd: string;
+    anchorText?: string;
+    status?: "open" | "resolved";
+}
+/**
+ * Resolved inline comment highlight data
+ */
+export interface InlineCommentHighlight {
+    id: string;
+    resolvedStart: number | null;
+    resolvedEnd: number | null;
+    isValid: boolean;
+    status?: "open" | "resolved";
+    anchorText?: string;
+}
+/**
+ * Position data for inline comment popovers
+ */
+export interface InlineCommentPosition {
+    top: number;
+    left: number;
+    height: number;
+}
+/**
+ * Props for TextareaCommentHighlightOverlay component
+ */
+export interface TextareaCommentHighlightOverlayProps {
+    /** List of resolved comments with position data */
+    comments: InlineCommentHighlight[];
+    /** Reference to the textarea element */
+    textareaRef: React.RefObject<HTMLTextAreaElement | null>;
+    /** Current text content */
+    content: string;
+    /** ID of the currently focused comment (optional) */
+    focusedCommentId?: string;
+    /** Callback when a comment highlight is clicked */
+    onCommentClick?: (commentId: string, position: InlineCommentPosition) => void;
+    /** Additional CSS class */
+    className?: string;
+}
+/**
+ * Ref handle for DocumentEditor component
+ */
+export interface DocumentEditorRef {
+    /** Insert content at the current cursor position */
+    insertContent: (content: string) => void;
+    /** Get the current content */
+    getContent: () => string;
+    /** Scroll to a specific line number */
+    scrollToLine: (lineNumber: number) => void;
+}
+/**
+ * Props for EditorContent component (internal to document page)
+ */
+export interface EditorContentProps {
+    /** Document ID */
+    documentId: string;
+    /** Document title */
+    title: string;
+    /** Callback when title changes */
+    onTitleChange: (title: string) => void;
+    /** Callback when generation updates the title */
+    onGeneratedTitleChange?: (title: string) => void;
+    /** Callback when delete is requested */
+    onDelete: () => void;
+    /** Whether user can edit */
+    canEdit: boolean;
+    /** Whether user can comment */
+    canComment: boolean;
+    /** Whether user can share */
+    canShare: boolean;
+    /** Current user info for comments */
+    currentUser: {
+        id: string;
+        name: string;
+        email?: string;
+        avatarUrl?: string;
+    } | null;
+    /** Users that can be mentioned in comments */
+    mentionableUsers: import("../comments/comments.interfaces").MentionableUser[];
+}
+/**
+ * Table of contents entry for markdown headings
+ */
+export interface DocumentTocItem {
+    /** Heading text */
+    text: string;
+    /** Heading level (1-6) */
+    level: number;
+    /** Line number (1-based) */
+    line: number;
+}
+/**
+ * Table of contents entry with slug id
+ */
+export interface DocumentTocEntry extends DocumentTocItem {
+    /** Slug id for linking */
+    id: string;
+}
+/**
+ * Props for ToolbarButton component
+ */
+export interface ToolbarButtonProps {
+    onClick: () => void;
+    isActive?: boolean;
+    disabled?: boolean;
+    tooltip: string;
+    icon: React.ReactNode;
+}
+/**
+ * Props for RightSidePanel component
+ */
+export interface RightSidePanelProps {
+    /** Document ID */
+    documentId: string;
+    /** Currently selected text (if any) */
+    selectionText?: string;
+    /** Full document content as plain text */
+    documentContent?: string;
+    /** Callback when content should be inserted into editor */
+    onInsertContent?: (content: string) => void;
+    /** Whether the panel is collapsed */
+    isCollapsed?: boolean;
+    /** Callback when collapse state changes */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Panel width in pixels (when expanded) */
+    width?: number;
+    /** Callback when width changes (for resize) */
+    onWidthChange?: (width: number) => void;
+    /** Minimum panel width */
+    minWidth?: number;
+    /** Maximum panel width (capped at 50% of viewport) */
+    maxWidth?: number;
+    /** Whether user can restore versions */
+    canRestore?: boolean;
+    /** Whether user can edit (controls AI panel visibility) */
+    canEdit?: boolean;
+    /** Whether user can comment */
+    canComment?: boolean;
+    /** Current user for comments */
+    currentUser?: {
+        id: string;
+        name: string;
+        email?: string;
+        avatarUrl?: string;
+    } | null;
+    /** Users that can be mentioned in comments */
+    mentionableUsers?: import("../comments/comments.interfaces").MentionableUser[];
+    /** Initial active tab */
+    initialTab?: "ai" | "comments" | "versions";
+    /** Additional class name */
+    className?: string;
+    /** Key to force refresh of comments (increment to refetch) */
+    commentsRefreshKey?: number;
+}
+/**
+ * Represents a collaborator currently viewing/editing a document
+ */
+export interface Collaborator {
+    /** User's client ID from yjs awareness */
+    clientId: number;
+    /** User ID */
+    userId: string;
+    /** Display name */
+    name: string;
+    /** Cursor/avatar color */
+    color: string;
+    /** Optional avatar image URL */
+    avatarUrl?: string;
+    /** Current cursor position (if in editor) */
+    cursor?: {
+        anchor: number;
+        head: number;
+    };
+}
+/**
+ * Options for useDocumentPresence hook
+ */
+export interface UseDocumentPresenceOptions {
+    /** Whether to include the local user in the collaborators list */
+    includeLocalUser?: boolean;
+}
+/**
+ * Return type for useDocumentPresence hook
+ */
+export interface UseDocumentPresenceReturn {
+    /** List of active collaborators */
+    collaborators: Collaborator[];
+    /** Total count of collaborators */
+    count: number;
+    /** Whether awareness is connected */
+    isConnected: boolean;
+    /** Update local user's cursor position */
+    updateCursor: (cursor: {
+        anchor: number;
+        head: number;
+    } | null) => void;
+}
+/**
+ * Props for PresenceAvatars component
+ */
+export interface PresenceAvatarsProps {
+    /** List of collaborators to display */
+    collaborators: Collaborator[];
+    /** Maximum number of avatars to show before "+N" */
+    maxAvatars?: number;
+    /** Size of avatar circles */
+    size?: "sm" | "md" | "lg";
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * Props for internal AvatarCircle component
+ */
+export interface AvatarCircleProps {
+    /** Display name */
+    name: string;
+    /** Avatar background color */
+    color: string;
+    /** Optional avatar image URL */
+    avatarUrl?: string;
+    /** Size variant */
+    size: "sm" | "md" | "lg";
+}
+/**
+ * Dependencies for CollaboratorService
+ */
+export interface CollaboratorServiceDeps {
+    logger?: Logger;
+    db?: DynamoDbService<import("../db/schemas/collab-collaborators.schema").CollabCollaboratorsTableSchema>;
+}
+/**
+ * Parameters for adding a collaborator to a document
+ */
+export interface AddCollaboratorParams {
+    documentId: string;
+    /** Document title for notifications */
+    documentTitle?: string;
+    userId: string;
+    userName: string;
+    userEmail: string;
+    userAvatar?: string;
+    permissionLevel: import("./collaboration.constants").PermissionLevel;
+    invitedById: string;
+    invitedByName: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for getting a single collaborator
+ */
+export interface GetCollaboratorParams {
+    documentId: string;
+    userId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for listing collaborators on a document
+ */
+export interface ListCollaboratorsParams {
+    documentId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for listing documents shared with a user
+ */
+export interface ListSharedDocumentsParams {
+    userId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for updating a collaborator's permission
+ */
+export interface UpdateCollaboratorParams {
+    documentId: string;
+    userId: string;
+    permissionLevel: import("./collaboration.constants").PermissionLevel;
+    updatedById: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for removing a collaborator
+ */
+export interface RemoveCollaboratorParams {
+    documentId: string;
+    userId: string;
+    removedById: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Response for collaborator list
+ */
+export interface ListCollaboratorsResponse {
+    collaborators: import("./collaboration.schemas").DocumentCollaborator[];
+}
+/**
+ * Response for shared documents list
+ */
+export interface ListSharedDocumentsResponse {
+    documentIds: string[];
+}
+/**
+ * Props for DocumentShareDialog component
+ */
+export interface DocumentShareDialogProps {
+    /** Whether the dialog is open */
+    open: boolean;
+    /** Callback when dialog open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Document ID to share */
+    documentId: string;
+    /** Document title for display */
+    documentTitle: string;
+    /** Current user's ID (to prevent self-sharing) */
+    currentUserId?: string;
+}
+/**
+ * Options for useDocumentShare hook
+ */
+export interface UseDocumentShareOptions {
+    /** Document ID */
+    documentId: string;
+    /** Whether to enable the query (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Return type for useDocumentShare hook
+ */
+export interface UseDocumentShareReturn {
+    /** List of collaborators */
+    collaborators: import("./collaboration.schemas").DocumentCollaborator[];
+    /** Whether the collaborators are loading */
+    isLoading: boolean;
+    /** Whether there's an error */
+    isError: boolean;
+    /** The error if any */
+    error: Error | null;
+    /** Refetch collaborators */
+    refetch: () => void;
+    /** Add a collaborator */
+    addCollaborator: (data: import("./collaboration.schemas").AddCollaboratorBody) => Promise<import("./collaboration.schemas").DocumentCollaborator>;
+    /** Whether adding is in progress */
+    isAdding: boolean;
+    /** Update a collaborator's permission */
+    updateCollaborator: (userId: string, permissionLevel: import("./collaboration.constants").PermissionLevel) => Promise<void>;
+    /** Whether updating is in progress */
+    isUpdating: boolean;
+    /** Remove a collaborator */
+    removeCollaborator: (userId: string) => Promise<void>;
+    /** Whether removing is in progress */
+    isRemoving: boolean;
+}
+/**
+ * Options for useDocumentPermission hook
+ */
+export interface UseDocumentPermissionOptions {
+    /** Document ID */
+    documentId: string;
+    /** Current user's ID */
+    userId: string;
+    /** Whether to enable the query (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Return type for useDocumentPermission hook
+ */
+export interface UseDocumentPermissionReturn {
+    /** User's permission level (null if not a collaborator) */
+    permissionLevel: import("./collaboration.constants").PermissionLevel | null;
+    /** Whether the permission is loading */
+    isLoading: boolean;
+    /** Whether there's an error */
+    isError: boolean;
+    /** Whether user is the document owner */
+    isOwner: boolean;
+    /** Whether user has admin permission */
+    isAdmin: boolean;
+    /** Whether user can edit the document */
+    canEdit: boolean;
+    /** Whether user can view the document */
+    canView: boolean;
+    /** Whether user can share the document */
+    canShare: boolean;
+    /** Whether user can delete the document */
+    canDelete: boolean;
+    /** Whether user can comment on the document */
+    canComment: boolean;
+}
+/**
+ * Dependencies for CommentService
+ */
+export interface CommentServiceDeps {
+    logger?: Logger;
+    db?: DynamoDbService<import("../db/schemas/collab-comments.schema").CollabCommentsTableSchema>;
+}
+/**
+ * Parameters for creating a comment
+ */
+export interface CreateCommentParams {
+    documentId: string;
+    /** Document title for notifications */
+    documentTitle?: string;
+    /** Anchor start position (Yjs relative position as bytes) */
+    anchorStart: Uint8Array;
+    /** Anchor end position (Yjs relative position as bytes) */
+    anchorEnd: Uint8Array;
+    anchorText?: string;
+    content: string;
+    authorId: string;
+    authorName: string;
+    authorEmail: string;
+    authorAvatar?: string;
+    parentId?: string;
+    mentions?: string[];
+    /** Map of user IDs to names for mention notifications */
+    mentionNames?: Record<string, string>;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for listing comments
+ */
+export interface ListCommentsParams {
+    documentId: string;
+    status?: import("./collaboration.constants").CommentStatus;
+    parentId?: string;
+    limit?: number;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for getting a single comment
+ */
+export interface GetCommentParams {
+    documentId: string;
+    commentId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for updating a comment
+ */
+export interface UpdateCommentParams {
+    documentId: string;
+    commentId: string;
+    content?: string;
+    mentions?: string[];
+    userId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for resolving a comment
+ */
+export interface ResolveCommentParams {
+    documentId: string;
+    commentId: string;
+    resolvedById: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for deleting a comment
+ */
+export interface DeleteCommentParams {
+    documentId: string;
+    commentId: string;
+    userId?: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Response for comment list
+ */
+export interface ListCommentsResponse {
+    comments: import("./collaboration.schemas").DocumentComment[];
+}
+/**
+ * Options for useDocumentVersions hook
+ */
+export interface UseDocumentVersionsOptions {
+    /** Document ID */
+    documentId: string;
+    /** Whether to enable the query (default: true) */
+    enabled?: boolean;
+    /** Callback when restore succeeds with the restored content (Yjs state) */
+    onRestoreSuccess?: (content: Uint8Array) => void;
+}
+/**
+ * Return type for useDocumentVersions hook
+ */
+export interface UseDocumentVersionsReturn {
+    /** List of versions (without content for efficiency) */
+    versions: DocumentVersionSummary[];
+    /** Whether versions are loading */
+    isLoading: boolean;
+    /** Whether there's an error */
+    isError: boolean;
+    /** The error if any */
+    error: Error | null;
+    /** Refetch versions */
+    refetch: () => void;
+    /** Create a new version snapshot */
+    createVersion: (params: import("./collaboration.schemas").CreateVersionBody) => Promise<void>;
+    /** Whether creating is in progress */
+    isCreating: boolean;
+    /** Restore a previous version */
+    restoreVersion: (versionId: string) => Promise<void>;
+    /** Whether restoring is in progress */
+    isRestoring: boolean;
+}
+/**
+ * Options for useMarkdownEditor hook
+ */
+export interface UseMarkdownEditorOptions {
+    /** Placeholder text when empty */
+    placeholder?: string;
+    /** Whether the editor is editable (default: true) */
+    editable?: boolean;
+    /** Callback when content changes */
+    onUpdate?: (content: string) => void;
+}
+/**
+ * Return type for useMarkdownEditor hook
+ */
+export interface UseMarkdownEditorReturn {
+    /** Current markdown content */
+    content: string;
+    /** Set markdown content (triggers sync) */
+    setContent: (content: string) => void;
+    /** Ref to attach to textarea for direct Y.Text binding */
+    textareaRef: React.RefObject<HTMLTextAreaElement | null>;
+    /** Whether the editor is ready */
+    isReady: boolean;
+    /** List of currently connected remote users */
+    connectedUsers: AwarenessUser[];
+    /** Total number of unique users online */
+    totalOnlineCount: number;
+    /** Insert text at cursor position */
+    insertText: (before: string, after?: string, defaultText?: string) => void;
+    /** Insert prefix at line start */
+    insertAtLineStart: (prefix: string) => void;
+    /** Undo last change */
+    undo: () => void;
+    /** Redo last undone change */
+    redo: () => void;
+    /** Whether undo is available */
+    canUndo: boolean;
+    /** Whether redo is available */
+    canRedo: boolean;
+}
+/**
+ * Props for DocumentList component
+ */
+export interface DocumentListProps {
+    /** Array of documents to display */
+    documents: CollabDocument[];
+    /** Whether documents are loading */
+    isLoading?: boolean;
+    /** Current filter */
+    filter?: import("./collaboration.constants").DocumentFilter;
+    /** Callback when filter changes */
+    onFilterChange?: (filter: import("./collaboration.constants").DocumentFilter) => void;
+    /** External search value */
+    search?: string;
+    /** External search change callback */
+    onSearchChange?: (search: string) => void;
+    /** External view mode */
+    viewMode?: import("./collaboration.constants").ViewMode;
+    /** External view mode change callback */
+    onViewModeChange?: (mode: import("./collaboration.constants").ViewMode) => void;
+    /** Current user ID for permission checks */
+    currentUserId?: string;
+    /** Callback when a document is opened */
+    onOpen?: (document: CollabDocument) => void;
+    /** Callback when a document is deleted (soft delete) */
+    onDelete?: (document: CollabDocument) => void;
+    /** Callback when a document is restored from trash */
+    onRestore?: (document: CollabDocument) => void;
+    /** Callback when a document is permanently deleted */
+    onPermanentDelete?: (document: CollabDocument) => void;
+    /** Whether user has permission to delete any document */
+    canDelete?: boolean;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * Props for DocumentListHeader component
+ */
+export interface DocumentListHeaderProps {
+    /** Current view mode */
+    viewMode: import("./collaboration.constants").ViewMode;
+    /** Callback when view mode changes */
+    onViewModeChange: (mode: import("./collaboration.constants").ViewMode) => void;
+    /** Current sort option */
+    sortOption: import("./collaboration.constants").SortOptionKey;
+    /** Callback when sort option changes */
+    onSortChange: (option: import("./collaboration.constants").SortOptionKey) => void;
+    /** Current filter */
+    filter: import("./collaboration.constants").DocumentFilter;
+    /** Callback when filter changes */
+    onFilterChange: (filter: import("./collaboration.constants").DocumentFilter) => void;
+    /** Current search value */
+    searchValue: string;
+    /** Callback when search value changes */
+    onSearchChange: (value: string) => void;
+    /** Callback when refresh is clicked */
+    onRefresh?: () => void;
+    /** Whether refresh is in progress */
+    isRefreshing?: boolean;
+    /** Optional column visibility dropdown for table view */
+    columnVisibilityDropdown?: React.ReactNode;
+}
+/**
+ * Props for DocumentCardGrid component
+ */
+export interface DocumentCardGridProps {
+    /** Array of documents to display */
+    documents: CollabDocument[];
+    /** Whether documents are loading */
+    loading?: boolean;
+    /** Callback when a document is opened */
+    onOpen?: (document: CollabDocument) => void;
+    /** Callback when a document is deleted */
+    onDelete?: (document: CollabDocument) => void;
+    /** Callback when a document is restored */
+    onRestore?: (document: CollabDocument) => void;
+    /** Callback when a document is permanently deleted */
+    onPermanentDelete?: (document: CollabDocument) => void;
+    /** Current user ID for ownership checks */
+    currentUserId?: string;
+    /** Whether user can delete documents */
+    canDelete?: boolean;
+    /** Message to show when list is empty */
+    emptyMessage?: string;
+    /** Description to show when list is empty */
+    emptyDescription?: string;
+}
+export interface DocumentCardProps {
+    /** Document data to display */
+    document: CollabDocument;
+    /** Callback when card is clicked to open document */
+    onOpen?: (document: CollabDocument) => void;
+    /** Callback when delete (move to trash) is clicked */
+    onDelete?: (document: CollabDocument) => void;
+    /** Callback when restore from trash is clicked */
+    onRestore?: (document: CollabDocument) => void;
+    /** Callback when permanent delete is clicked */
+    onPermanentDelete?: (document: CollabDocument) => void;
+    /** Whether the current user owns this document */
+    isOwner?: boolean;
+    /** Whether the current user has edit permission */
+    canEdit?: boolean;
+    /** Whether the current user has delete permission */
+    canDelete?: boolean;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * Return type for useDocumentsView hook
+ */
+export interface UseDocumentsViewReturn {
+    /** Current view mode */
+    viewMode: import("./collaboration.constants").ViewMode;
+    /** Set view mode */
+    setViewMode: (mode: import("./collaboration.constants").ViewMode) => void;
+    /** Current sort option */
+    sortOption: import("./collaboration.constants").SortOptionKey;
+    /** Set sort option */
+    setSortOption: (option: import("./collaboration.constants").SortOptionKey) => void;
+    /** Current search value */
+    searchValue: string;
+    /** Set search value */
+    setSearchValue: (value: string) => void;
+}
+/**
+ * Dependencies for VersionService
+ */
+export interface VersionServiceDeps {
+    logger?: Logger;
+    db?: DynamoDbService<import("../db/schemas/collab-versions.schema").CollabVersionsTableSchema>;
+}
+/**
+ * Parameters for creating a version
+ */
+export interface CreateVersionParams {
+    documentId: string;
+    content: Uint8Array;
+    wordCount: number;
+    editorId: string;
+    editorName: string;
+    snapshotType: import("./collaboration.constants").SnapshotType;
+    label?: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for listing versions
+ */
+export interface ListVersionsParams {
+    documentId: string;
+    limit?: number;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for getting a single version
+ */
+export interface GetVersionParams {
+    documentId: string;
+    versionId: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Parameters for restoring a version
+ */
+export interface RestoreVersionParams {
+    documentId: string;
+    versionId: string;
+    tenantId: string;
+    userId: string;
+    userName: string;
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * Version summary for list responses (excludes binary content for efficiency)
+ */
+export type DocumentVersionSummary = Omit<import("./collaboration.schemas").DocumentVersion, "content">;
+/**
+ * Response for version list
+ */
+export interface ListVersionsResponse {
+    versions: DocumentVersionSummary[];
+}
+/**
+ * API response type for version - content is base64 encoded for JSON transport
+ */
+export interface VersionApiResponse {
+    id: string;
+    documentId: string;
+    /** Content as base64-encoded Yjs state */
+    content: string;
+    contentS3Key?: string;
+    wordCount: number;
+    editorId: string;
+    editorName: string;
+    snapshotType: import("./collaboration.constants").SnapshotType;
+    label?: string;
+    createdAt: number;
+}
+/**
+ * Props for TextareaCursorOverlay component
+ */
+export interface TextareaCursorOverlayProps {
+    /** List of collaborators with cursor positions */
+    collaborators: Collaborator[];
+    /** Reference to the textarea element */
+    textareaRef: React.RefObject<HTMLTextAreaElement | null>;
+    /** Current text content */
+    content: string;
+    /** Additional CSS class */
+    className?: string;
+}
+/**
+ * Message in the AI assistant conversation
+ */
+export interface AiAssistantMessage {
+    id: string;
+    role: "user" | "assistant";
+    content: string;
+    timestamp: number;
+    isStreaming?: boolean;
+}
+/**
+ * Generated content awaiting user action
+ */
+export interface PendingContent {
+    /** The generated content text */
+    content: string;
+    /** The original prompt that generated this content */
+    prompt: string;
+    /** When the content was generated */
+    generatedAt: number;
+}
+/**
+ * Context for AI generation including text and optional file attachments
+ */
+export interface AiGenerationContext {
+    /** Selected text to use as context */
+    selectionText?: string;
+    /** Full document content to use as context */
+    documentContent?: string;
+    /** File attachments to include */
+    files?: import("ai").FileUIPart[];
+}
+/**
+ * Model/agent selection for AI generation
+ */
+export interface AiModelSelection {
+    /** Provider ID (for model selection) */
+    providerId?: string;
+    /** Model ID (for model selection) */
+    modelId?: string;
+    /** Agent ID (for agent selection) */
+    agentId?: string;
+}
+/**
+ * Options for useAiAssistant hook
+ */
+export interface UseAiAssistantOptions {
+    /** Document ID */
+    documentId: string;
+    /** Callback when content is accepted and should be inserted into the editor */
+    onAccept?: (content: string) => void;
+    /** Callback when generation starts */
+    onGenerationStart?: () => void;
+    /** Callback when generation completes */
+    onGenerationComplete?: (content: string) => void;
+    /** Callback when generation fails */
+    onGenerationError?: (error: Error) => void;
+}
+/**
+ * Return type for useAiAssistant hook
+ */
+export interface UseAiAssistantReturn {
+    /** Current context mode (selection or full-document) */
+    contextMode: import("./collaboration.constants").AiContextMode;
+    /** Set the context mode */
+    setContextMode: (mode: import("./collaboration.constants").AiContextMode) => void;
+    /** Conversation messages */
+    messages: AiAssistantMessage[];
+    /** Raw UIMessages from AI SDK useChat (includes tool parts) */
+    uiMessages: UIMessage[];
+    /** Currently pending content awaiting accept/reject */
+    pendingContent: PendingContent | null;
+    /** Whether generation is in progress */
+    isGenerating: boolean;
+    /** Current streaming content (partial) */
+    streamingContent: string;
+    /** Error message if generation failed */
+    error: string | null;
+    /** Current model/agent selection */
+    modelSelection: AiModelSelection;
+    /** Update model/agent selection */
+    setModelSelection: (selection: AiModelSelection) => void;
+    /** Generate content from a prompt */
+    generate: (prompt: string, context?: AiGenerationContext) => void;
+    /** Accept the pending content */
+    acceptContent: () => void;
+    /** Reject the pending content */
+    rejectContent: () => void;
+    /** Clear all messages and reset state */
+    clearMessages: () => void;
+    /** Abort current generation */
+    abort: () => void;
+}
+//# sourceMappingURL=collaboration.interfaces.d.ts.map