@veltdev/sdk-staging 5.0.2-beta.4 → 5.0.2-beta.40

package/app/models/data/notification-resolver.data.model.d.ts

@@ -0,0 +1,39 @@
+import { ResolverEndpointConfig, ResolverResponse, RetryConfig } from "./resolver.data.model";
+import { User } from "./user.data.model";
+export interface NotificationDataProvider {
+    get?: (request: GetNotificationResolverRequest) => Promise<ResolverResponse<Record<string, PartialNotification>>>;
+    delete?: (request: DeleteNotificationResolverRequest) => Promise<ResolverResponse<undefined>>;
+    config?: NotificationResolverConfig;
+}
+export interface NotificationResolverConfig {
+    resolveTimeout?: number;
+    getRetryConfig?: RetryConfig;
+    deleteRetryConfig?: RetryConfig;
+    getConfig?: ResolverEndpointConfig;
+    deleteConfig?: ResolverEndpointConfig;
+}
+export interface GetNotificationResolverRequest {
+    organizationId: string;
+    notificationIds: string[];
+}
+export interface DeleteNotificationResolverRequest {
+    notificationId: string;
+    organizationId: string;
+}
+export interface PartialNotification {
+    notificationId: string;
+    displayHeadlineMessageTemplate?: string;
+    displayHeadlineMessageTemplateData?: {
+        actionUser?: User;
+        recipientUser?: User;
+        actionMessage?: string;
+        [key: string]: any;
+    };
+    displayBodyMessage?: string;
+    displayBodyMessageTemplate?: string;
+    displayBodyMessageTemplateData?: {
+        [key: string]: any;
+    };
+    notificationSourceData?: any;
+    [key: string]: any;
+}

package/app/models/data/notification.model.d.ts

@@ -137,6 +137,10 @@ export declare class Notification {
      * Is comment text available
      */
     isCommentResolverUsed?: boolean;
+    /**
+     * Is notification resolver used
+     */
+    isNotificationResolverUsed?: boolean;
     /**
      * Display body message template
        */

package/app/models/data/presence-user.data.model.d.ts

@@ -83,4 +83,9 @@ export declare class PresenceUser {
     initial?: string;
     isTabAway?: boolean;
     isUserIdle?: boolean;
+    /**
+     * Whether this custom user is local-only (not persisted to DB).
+     * Only applicable to users added via addUser API.
+     */
+    localOnly?: boolean;
 }

package/app/models/data/provider.data.model.d.ts

@@ -1,10 +1,17 @@
+import { ActivityAnnotationDataProvider } from "./activity-resolver.data.model";
 import { CommentAnnotationDataProvider } from "./comment-resolver.data.model";
 import { AttachmentDataProvider } from "./attachment-resolver.data.model";
+import { NotificationDataProvider } from "./notification-resolver.data.model";
 import { ReactionAnnotationDataProvider } from "./reaction-resolver.data.model";
-import { UserDataProvider } from "./user-resolver.data.model";
+import { RecorderAnnotationDataProvider } from "./recorder-resolver.data.model";
+import { AnonymousUserDataProvider, UserDataProvider } from "./user-resolver.data.model";
 export interface VeltDataProvider {
     comment?: CommentAnnotationDataProvider;
     user?: UserDataProvider;
     reaction?: ReactionAnnotationDataProvider;
     attachment?: AttachmentDataProvider;
+    anonymousUser?: AnonymousUserDataProvider;
+    recorder?: RecorderAnnotationDataProvider;
+    notification?: NotificationDataProvider;
+    activity?: ActivityAnnotationDataProvider;
 }

package/app/models/data/reaction-resolver.data.model.d.ts

@@ -4,9 +4,9 @@ import { PartialUser } from "./comment-resolver.data.model";
 import { ReactionAnnotation } from "./reaction-annotation.data.model";
 import { ResolverConfig, ResolverResponse } from "./resolver.data.model";
 export interface ReactionAnnotationDataProvider {
-    get: (request: GetReactionResolverRequest) => Promise<ResolverResponse<Record<string, PartialReactionAnnotation>>>;
-    save: (request: SaveReactionResolverRequest) => Promise<ResolverResponse<undefined>>;
-    delete: (request: DeleteReactionResolverRequest) => Promise<ResolverResponse<undefined>>;
+    get?: (request: GetReactionResolverRequest) => Promise<ResolverResponse<Record<string, PartialReactionAnnotation>>>;
+    save?: (request: SaveReactionResolverRequest) => Promise<ResolverResponse<undefined>>;
+    delete?: (request: DeleteReactionResolverRequest) => Promise<ResolverResponse<undefined>>;
     config?: ResolverConfig;
 }
 export interface GetReactionResolverRequest {

package/app/models/data/recorder-annotation.data.model.d.ts

@@ -150,6 +150,17 @@ export declare class RecorderAnnotation {
     chunkUrls?: {
         [key: number]: string;
     };
+    /**
+     * Whether the recorder resolver is used for this annotation.
+     * Used by UI components to show loading states while resolver data is being fetched.
+     */
+    isRecorderResolverUsed?: boolean;
+    /**
+     * Whether the real recording URL is available.
+     * Set to false when the annotation is first saved (URL is still a local blob),
+     * and true once the actual URL from storage is available after the async upload completes.
+     */
+    isUrlAvailable?: boolean;
 }
 export interface RecorderAnnotationEditVersion {
     from?: User;

package/app/models/data/recorder-events.data.model.d.ts

@@ -4,6 +4,8 @@ export interface TranscriptionDoneEvent extends RecorderData {
 }
 export interface RecordingDoneEvent extends RecorderData {
 }
+export interface RecordingDoneLocalEvent extends RecorderData {
+}
 export interface RecordingDeleteEvent extends RecorderData {
 }
 export interface RecordingEditDoneEvent extends RecorderData {
@@ -35,6 +37,7 @@ export interface RecordingSaveInitiatedEvent {
 export type RecorderEventTypesMap = {
     [RecorderEventTypes.TRANSCRIPTION_DONE]: TranscriptionDoneEvent;
     [RecorderEventTypes.RECORDING_DONE]: RecordingDoneEvent;
+    [RecorderEventTypes.RECORDING_DONE_LOCAL]: RecordingDoneLocalEvent;
     [RecorderEventTypes.RECORDING_EDIT_DONE]: RecordingEditDoneEvent;
     [RecorderEventTypes.DELETE_RECORDING]: RecordingDeleteEvent;
     [RecorderEventTypes.RECORDING_STARTED]: RecordingStartedEvent;

package/app/models/data/recorder-resolver.data.model.d.ts

@@ -0,0 +1,58 @@
+import { ResolverActions } from "../../utils/enums";
+import { AttachmentDataProvider } from "./attachment-resolver.data.model";
+import { BaseMetadata } from "./base-metadata.data.model";
+import { RecorderAnnotation } from "./recorder-annotation.data.model";
+import { ResolverConfig, ResolverResponse } from "./resolver.data.model";
+import { Attachment } from "./attachment.model";
+import { Transcription } from "./transcription.data.model";
+import { User } from "./user.data.model";
+export interface RecorderAnnotationDataProvider {
+    get?: (request: GetRecorderResolverRequest) => Promise<ResolverResponse<Record<string, PartialRecorderAnnotation>>>;
+    save?: (request: SaveRecorderResolverRequest) => Promise<ResolverResponse<SaveRecorderResolverData | undefined>>;
+    delete?: (request: DeleteRecorderResolverRequest) => Promise<ResolverResponse<undefined>>;
+    config?: ResolverConfig;
+    uploadChunks?: boolean;
+    storage?: AttachmentDataProvider;
+}
+export interface GetRecorderResolverRequest {
+    organizationId: string;
+    recorderAnnotationIds?: string[];
+    documentIds?: string[];
+}
+export interface SaveRecorderResolverRequest {
+    recorderAnnotation: Record<string, PartialRecorderAnnotation>;
+    event?: ResolverActions;
+    metadata?: BaseMetadata;
+}
+export interface SaveRecorderResolverData {
+    transcription?: Transcription;
+    attachment?: Attachment | null;
+    attachments?: Attachment[];
+}
+export interface DeleteRecorderResolverRequest {
+    recorderAnnotationId: string;
+    metadata?: BaseMetadata;
+    event?: ResolverActions;
+}
+export interface PartialRecorderAnnotation {
+    annotationId: string;
+    metadata?: BaseMetadata;
+    from?: User;
+    transcription?: Transcription;
+    attachment?: Attachment | null;
+    attachments?: Attachment[];
+    chunkUrls?: Record<number, string>;
+    recordingEditVersions?: Record<number, PartialRecorderAnnotationEditVersion>;
+    [key: string]: any;
+}
+export interface PartialRecorderAnnotationEditVersion {
+    from?: User;
+    attachment?: Attachment | null;
+    attachments?: Attachment[];
+    transcription?: Transcription;
+}
+export interface PartialRecorderAnnotationResult {
+    strippedData: Record<string, PartialRecorderAnnotation> | null;
+    originalData: RecorderAnnotation | null;
+    eventType?: ResolverActions;
+}

package/app/models/data/resolver.data.model.d.ts

@@ -9,6 +9,7 @@ export interface ResolverConfig {
     getRetryConfig?: RetryConfig;
     resolveUsersConfig?: ResolveUsersConfig;
     fieldsToRemove?: string[];
+    additionalFields?: string[];
     getConfig?: ResolverEndpointConfig;
     saveConfig?: ResolverEndpointConfig;
     deleteConfig?: ResolverEndpointConfig;

package/app/models/data/rewriter-events.data.model.d.ts

@@ -0,0 +1,40 @@
+import { TargetTextRange } from './target-text-range.data.model';
+import { RewriterEventTypes } from '../../utils/enums';
+export interface TextSelectedEvent {
+    selectionId: string;
+    text: string;
+    targetTextRange: TargetTextRange;
+}
+export interface RewriterAskAiRequest {
+    model: string;
+    prompt: string;
+    selectedText: string;
+}
+export interface RewriterReplaceTextRequest {
+    text: string;
+    event: TextSelectedEvent;
+}
+export interface RewriterAddCommentRequest {
+    text: string;
+    event: TextSelectedEvent;
+}
+export interface RewriterAskAiResponse {
+    text: string;
+    success: boolean;
+    error?: string;
+}
+export interface RewriterReplaceTextResponse {
+    success: boolean;
+    originalText: string;
+    replacedText: string;
+    error?: string;
+}
+export interface RewriterAddCommentResponse {
+    success: boolean;
+    annotationId?: string;
+    commentText?: string;
+    error?: string;
+}
+export type RewriterEventTypesMap = {
+    [RewriterEventTypes.TEXT_SELECTED]: TextSelectedEvent;
+};

package/app/models/data/user-resolver.data.model.d.ts

@@ -1,10 +1,24 @@
-import { ResolverConfig } from "./resolver.data.model";
+import { ResolverConfig, ResolverResponse, RetryConfig } from "./resolver.data.model";
 import { User } from "./user.data.model";
 export interface UserDataProvider {
     get(userIds: string[]): Promise<Record<string, User>>;
     config?: ResolverConfig;
     resolveTimeout?: number;
 }
+export interface AnonymousUserDataProvider {
+    resolveUserIdsByEmail(request: ResolveUserIdsByEmailRequest): Promise<ResolverResponse<Record<string, string>>>;
+    config?: AnonymousUserDataProviderConfig;
+}
+export interface AnonymousUserDataProviderConfig {
+    resolveTimeout?: number;
+    getRetryConfig?: RetryConfig;
+}
+export interface ResolveUserIdsByEmailRequest {
+    organizationId: string;
+    documentId?: string;
+    folderId?: string;
+    emails: string[];
+}
 export interface GetUserResolverRequest {
     organizationId: string;
     userIds: string[];
@@ -19,6 +33,7 @@ export interface GetUserPermissionsResponse {
         folders?: {
             [folderId: string]: {
                 accessRole?: UserPermissionAccessRole;
+                accessType?: string;
                 expiresAt?: number;
                 error?: string;
                 errorCode?: UserPermissionAccessRoleResult;
@@ -35,6 +50,7 @@ export interface GetUserPermissionsResponse {
         documents?: {
             [documentId: string]: {
                 accessRole?: UserPermissionAccessRole;
+                accessType?: string;
                 expiresAt?: number;
                 error?: string;
                 errorCode?: UserPermissionAccessRoleResult;

package/app/models/data/user.data.model.d.ts

@@ -12,6 +12,8 @@ export declare class User {
      * Default: Random avatar name.
      */
     name?: string;
+    email_lowercase?: string;
+    name_lowercase?: string;
     clientUserName?: string;
     /**
     * Your user's display picture URL.

package/app/models/element/activity-element.model.d.ts

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { Observable } from "rxjs";
+import { ActivityRecord, ActivitySubscribeConfig, CreateActivityData } from "../data/activity.data.model";
+
+export declare class ActivityElement {
+
+    /**
+     * Subscribe to activities with optional filtering configuration.
+     * Returns an Observable that, when unsubscribed, automatically cleans up the internal subscription.
+     * @param config Optional configuration to filter activities by scope, feature types, action types, etc.
+     * @returns Observable<ActivityRecord[] | null>
+     */
+    getAllActivities: (config?: ActivitySubscribeConfig) => Observable<ActivityRecord[] | null>;
+
+    /**
+     * Create a new activity record.
+     * @param data The activity data including feature type, action type, target entity, etc.
+     * @returns Promise<void>
+     */
+    createActivity: (data: CreateActivityData) => Promise<void>;
+
+    constructor();
+
+    /**
+     * Subscribe to activities with optional filtering configuration.
+     */
+    private _getAllActivities;
+
+    /**
+     * Create a new activity record.
+     */
+    private _createActivity;
+}

package/app/models/element/comment-element.model.d.ts

@@ -291,14 +291,14 @@ export declare class CommentElement {
   public disableStatus: () => any;
 
   /**
-   * To enable visibility option dropdown on comments
+   * To enable visibility options on comments
    */
-  public enableVisibilityOptionDropdown: () => any;
+  public enableVisibilityOptions: () => any;
 
   /**
-   * To disable visibility option dropdown on comments
+   * To disable visibility options on comments
    */
-  public disableVisibilityOptionDropdown: () => any;
+  public disableVisibilityOptions: () => any;
 
   /**
    * To enable feature to show resolve button
@@ -1385,6 +1385,16 @@ export declare class CommentElement {
    */
   public getComposerData: (request: GetComposerDataRequest) => ComposerTextChangeEvent | null;
 
+  /**
+   * To enable pin drag
+   */
+  public enablePinDrag: () => void;
+
+  /**
+   * To disable pin drag
+   */
+  public disablePinDrag: () => void;
+
   constructor();
   /**
    * Subscribe to comments on the current document.
@@ -1626,14 +1636,14 @@ export declare class CommentElement {
   private _disableStatus;
 
   /**
-   * To enable visibility option dropdown on comments
+   * To enable visibility options on comments
    */
-  private _enableVisibilityOptionDropdown;
+  private _enableVisibilityOptions;
 
   /**
-   * To disable visibility option dropdown on comments
+   * To disable visibility options on comments
    */
-  private _disableVisibilityOptionDropdown;
+  private _disableVisibilityOptions;
 
   /**
    * To enable feature to show resolve button
@@ -2741,4 +2751,14 @@ export declare class CommentElement {
    * @param type 'dropdown' | 'checkbox'
    */
   private _setAssignToType;
+
+  /**
+   * To enable pin drag
+   */
+  private _enablePinDrag;
+
+  /**
+   * To disable pin drag
+   */
+  private _disablePinDrag;
 }

package/app/models/element/crdt-element.model.d.ts

@@ -1,5 +1,5 @@
 // @ts-nocheck
-import { CrdtGetDataQuery, CrdtGetVersionQuery, CrdtOnDataChangeQuery, CrdtOnPresenceChangeQuery, CrdtOnRegisteredUserChangeQuery, CrdtOnStateChangeQuery, CrdtRegisterSyncUserQuery, CrdtSetPresenceQuery, CrdtSaveVersionQuery, CrdtUpdateDataQuery, CrdtUpdateStateQuery } from "../data/crdt.data.model";
+import { CrdtGetDataQuery, CrdtGetMessagesQuery, CrdtGetSnapshotQuery, CrdtGetVersionQuery, CrdtGetVersionsQuery, CrdtMessageData, CrdtOnDataChangeQuery, CrdtOnMessageQuery, CrdtOnPresenceChangeQuery, CrdtOnRegisteredUserChangeQuery, CrdtOnStateChangeQuery, CrdtPruneMessagesQuery, CrdtPushMessageQuery, CrdtRegisterSyncUserQuery, CrdtSaveSnapshotQuery, CrdtSetPresenceQuery, CrdtSaveVersionQuery, CrdtSnapshotData, CrdtUpdateDataQuery, CrdtUpdateStateQuery } from "../data/crdt.data.model";
 import { CrdtEventTypesMap } from "../data/crdt-events.data.model";
 
 export declare class CrdtElement {
@@ -80,6 +80,12 @@ export declare class CrdtElement {
      */
     getVersion: (getVersionQuery: CrdtGetVersionQuery) => Promise<any>;
 
+    /**
+     * Get all versions of a specific CRDT document
+     * @param id Document ID
+     */
+    getVersions: (getVersionsQuery: CrdtGetVersionsQuery) => Promise<any>;
+
     /**
      * Enable webhook
      */
@@ -96,6 +102,51 @@ export declare class CrdtElement {
      */
     setWebhookDebounceTime: (time: number) => void;
 
+    /**
+     * Push a lib0-encoded message to the unified message stream.
+     * Uses Firebase push() for chronologically-ordered keys.
+     * Carries both sync (type 0) and awareness (type 1) messages.
+     * @param pushMessageQuery - contains id, data (encoded bytes), yjsClientId (Y.Doc client ID), optional messageType and eventData
+     */
+    pushMessage: (pushMessageQuery: CrdtPushMessageQuery) => Promise<void>;
+    /**
+     * Subscribe to the unified message stream for real-time sync.
+     * Emits each new message individually as it arrives (streaming pattern).
+     * Returns an unsubscribe function.
+     * @param onMessageQuery - contains id, callback, and optional afterTs for filtering
+     */
+    onMessage: (onMessageQuery: CrdtOnMessageQuery) => () => void;
+    /**
+     * Fetch all messages after a given timestamp (one-time read).
+     * Used for message replay during initial load (y-redis pattern).
+     * @param getMessagesQuery - contains id and optional afterTs
+     */
+    getMessages: (getMessagesQuery: CrdtGetMessagesQuery) => Promise<CrdtMessageData[]>;
+    /**
+     * Get the latest full-state snapshot for a document.
+     * Used as the baseline for message replay during initial load.
+     * @param getSnapshotQuery - contains id
+     */
+    getSnapshot: (getSnapshotQuery: CrdtGetSnapshotQuery) => Promise<CrdtSnapshotData | null>;
+    /**
+     * Save a full-state snapshot (state + vector) for fast initial load.
+     * Called periodically to create checkpoints, enabling message pruning.
+     * @param saveSnapshotQuery - contains id, state (Y.Doc update), and vector (state vector)
+     */
+    saveSnapshot: (saveSnapshotQuery: CrdtSaveSnapshotQuery) => Promise<void>;
+    /**
+     * Remove messages older than the given timestamp from the message stream.
+     * Called after saving a snapshot to keep the message stream bounded.
+     * @param pruneMessagesQuery - contains id and beforeTs
+     */
+    pruneMessages: (pruneMessagesQuery: CrdtPruneMessagesQuery) => Promise<void>;
+
+    /**
+     * To set activity debounce time for batching CRDT edits (Default value is 10 minutes)
+     * @param time debounce time in milliseconds (minimum: 10 seconds)
+     */
+    setActivityDebounceTime: (time: number) => void;
+
     /**
      * Subscribe to crdt actions
      * @param action Action to subscribe to
@@ -188,6 +239,36 @@ export declare class CrdtElement {
      */
     private _getVersions;
 
+    /**
+     * Push a message to the unified message stream
+     */
+    private _pushMessage;
+
+    /**
+     * Subscribe to the unified message stream
+     */
+    private _onMessage;
+
+    /**
+     * Fetch all messages after a given timestamp
+     */
+    private _getMessages;
+
+    /**
+     * Get the latest snapshot for a document
+     */
+    private _getSnapshot;
+
+    /**
+     * Save a full-state snapshot
+     */
+    private _saveSnapshot;
+
+    /**
+     * Remove messages older than a given timestamp
+     */
+    private _pruneMessages;
+
     /**
      * Enable webhook
      */
@@ -204,6 +285,12 @@ export declare class CrdtElement {
      */
     private _setWebhookDebounceTime;
 
+    /**
+     * Set activity debounce time for batching CRDT edits
+     * @param time debounce time in milliseconds (minimum: 10 seconds)
+     */
+    private _setActivityDebounceTime;
+
     /**
      * Subscribe to crdt actions
      * @param action Action to subscribe to

package/app/models/element/presence-element.model.d.ts

@@ -50,6 +50,21 @@ export declare class PresenceElement {
      * Subscribe to presence events
      */
     on: <T extends keyof PresenceEventTypesMap>(action: T) => Observable<PresenceEventTypesMap[T]>;
+
+    /**
+     * Add a custom user to the presence list (e.g., an AI agent).
+     * The user will appear in presence alongside real users.
+     * @param request Object containing user data with at least userId required.
+     */
+    addUser: (request: { user: Partial<PresenceUser>, localOnly?: boolean }) => void;
+
+    /**
+     * Remove a previously added custom user from the presence list.
+     * @param request Object containing user data with at least userId required, and optional localOnly flag.
+     * @param request.localOnly If true, user is only removed locally (not removed from DB). Default: false.
+     */
+    removeUser: (request: { user: Partial<PresenceUser>, localOnly?: boolean }) => void;
+
     constructor();
     /**
      * Subscribe to a list of all online users who are either active or inactive on the current document.
@@ -95,4 +110,14 @@ export declare class PresenceElement {
      * Subscribe to presence events
      */
     private _on;
+
+    /**
+     * Add a custom user to the presence list
+     */
+    private _addUser;
+
+    /**
+     * Remove a custom user from the presence list
+     */
+    private _removeUser;
 }