@veltdev/types 5.0.2-beta.9 → 5.0.2

package/app/client/snippyly.model.d.ts

@@ -24,6 +24,7 @@ import { TagElement } from "../models/element/tag-element.model";
 import { FeatureType } from "../utils/enums";
 import { UserContact } from "../models/data/user-contact.data.model";
 import { DocumentMetadata } from "../models/data/document-metadata.model";
+import { PageInfo } from "../models/data/page-info.model";
 import { ReactionElement } from "../models/element/reaction-element.model";
 import { CrdtElement } from "../models/element/crdt-element.model";
 import { VeltEventMetadata, VeltDebugInfo } from "../models/data/event-metadata.data.model";
@@ -55,6 +56,23 @@ export declare class Snippyly {
     * @param documentMetadata Document Metadata
     */
    setDocument: (id: string, documentMetadata?: DocumentMetadata) => Promise<void>;
+   /**
+    * Provide custom page info that the SDK should use instead of generating it from the browser
+    * (`window.location` / `document.title`). Newly created data (comments, reactions, recordings,
+    * presence, cursors, etc.) will use the provided page info. Already saved/existing data is not
+    * affected.
+    * @param pageInfo client-provided page info
+    * @param options optional; pass a `documentId` to scope the page info to a specific document
+    *                (per-document page info takes precedence over the global page info)
+    */
+   setPageInfo: (pageInfo: PageInfo, options?: { documentId?: string; }) => void;
+   /**
+    * Clear custom page info previously set via `setPageInfo`. The SDK will resume generating
+    * page info from the browser.
+    * @param options optional; pass a `documentId` to clear only that document's page info,
+    *                otherwise the global page info is cleared
+    */
+   clearPageInfo: (options?: { documentId?: string; }) => void;
    /**
     * Tell us the unique ID of the current document/resource on which you want to enable collaboration.
     * @param id unique document ID
@@ -365,7 +383,7 @@ export declare class Snippyly {
    /**
     * To update user contact list.
     */
-   updateContactList: (userContacts: UserContact[], config?: { merge: boolean }) => void;
+   updateContactList: (userContacts: UserContact[], config?: { merge: boolean, filters?: boolean }) => void;
 
    /**
     * To get document metadata.
@@ -408,6 +426,16 @@ export declare class Snippyly {
     */
    disableSafeEval: () => void;
 
+   /**
+    * Enable Firestore persistent cache for offline support.
+    */
+   enableFirestorePersistentCache: (config?: { ha?: boolean }) => void;
+
+   /**
+    * Disable Firestore persistent cache.
+    */
+   disableFirestorePersistentCache: (config?: { ha?: boolean }) => void;
+
    /**
     * To reset the button toggle map.
     */

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

@@ -0,0 +1,27 @@
+import { BaseMetadata } from './base-metadata.data.model';
+import { ActivityChanges } from './activity.data.model';
+import { ResolverConfig, ResolverResponse } from './resolver.data.model';
+export interface PartialActivityRecord {
+    id: string;
+    metadata?: BaseMetadata;
+    changes?: ActivityChanges;
+    entityData?: unknown;
+    entityTargetData?: unknown;
+    displayMessageTemplateData?: Record<string, unknown>;
+    [key: string]: any;
+}
+export interface ActivityAnnotationDataProvider {
+    get?: (request: GetActivityResolverRequest) => Promise<ResolverResponse<Record<string, PartialActivityRecord>>>;
+    save?: (request: SaveActivityResolverRequest) => Promise<ResolverResponse<undefined>>;
+    config?: ResolverConfig;
+}
+export interface GetActivityResolverRequest {
+    activityIds?: string[];
+    documentIds?: string[];
+    organizationId?: string;
+}
+export interface SaveActivityResolverRequest {
+    activity: Record<string, PartialActivityRecord>;
+    event?: string;
+    metadata?: BaseMetadata;
+}

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

@@ -23,6 +23,8 @@ export declare const CommentActivityActionTypes: {
     readonly APPROVE: "comment_annotation.approve";
     readonly ACCEPT: "comment.accept";
     readonly REJECT: "comment.reject";
+    readonly SUGGESTION_ACCEPT: "comment_annotation.suggestion_accept";
+    readonly SUGGESTION_REJECT: "comment_annotation.suggestion_reject";
     readonly REACTION_ADD: "comment.reaction_add";
     readonly REACTION_DELETE: "comment.reaction_delete";
     readonly SUBSCRIBE: "comment_annotation.subscribe";
@@ -115,6 +117,8 @@ export declare class ActivityRecord<TEntity = unknown, TTarget = unknown> {
     actionIcon?: string;
     /** If true, this activity cannot be updated or deleted via REST API */
     immutable?: boolean;
+    /** If true, this activity was stripped by the activity resolver (for UI loading states) */
+    isActivityResolverUsed?: boolean;
 }
 /**
  * Configuration for subscribing to activities.

package/app/models/data/agent-suggestion.data.model.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Public configuration surface for AI agent suggestion comment actions.
+ *
+ * Hosts can override or augment the built-in accept (convert suggestion ->
+ * comment) and reject (delete) actions rendered on an agent suggestion card.
+ * When no config is provided, the built-in defaults are used (INV-004).
+ *
+ * Part of the SDK public API (exported via velt-types). Backward-compatible /
+ * additive — see specs/agent-suggestion-comment-ui/spec.md `## Outbound contract changes`.
+ */
+import { CommentAnnotation } from './comment-annotation.data.model';
+/**
+ * A single host-defined action button on an agent suggestion card.
+ */
+export interface AgentSuggestionAction {
+    /** Stable identifier for the action. */
+    id: string;
+    /** Display label (button text / aria-label). */
+    label?: string;
+    /** Optional icon identifier or URL. */
+    icon?: string;
+    /**
+     * Invoked when the action button is clicked. Receives the raw
+     * CommentAnnotation (review decision 2026-06-03 — accepted public-contract
+     * surface). Handler throws are caught by the SDK (EC-006).
+     */
+    onClick: (annotation: CommentAnnotation) => void | Promise<void>;
+}
+/**
+ * Host configuration for agent suggestion card actions.
+ * When `actions` is provided it replaces the default accept/reject pair.
+ */
+export interface AgentSuggestionActionsConfig {
+    actions?: AgentSuggestionAction[];
+}
+/**
+ * Discriminator for the bespoke agent-suggestion overflow-menu rows.
+ * Drives the icon, label and click action of the generic menu-item primitive.
+ */
+export type AgentSuggestionMenuItemType = 'copy-link' | 'delete';
+/**
+ * Canonical agent-suggestion overflow-menu item types.
+ * Avoids repeating the discriminator string literals across primitives.
+ */
+export declare const AGENT_SUGGESTION_MENU_ITEM_TYPE: {
+    readonly COPY_LINK: "copy-link";
+    readonly DELETE: "delete";
+};
+/**
+ * Translation keys / labels used by the agent-suggestion overflow menu.
+ * Centralised so the menu-item, label and trigger primitives stay in sync.
+ */
+export declare const AGENT_SUGGESTION_MENU_LABEL: {
+    readonly COPY_LINK: "Copy link";
+    readonly LINK_COPIED: "Link copied!";
+    readonly DELETE_THREAD: "Delete thread";
+};

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

@@ -35,6 +35,7 @@ export declare class AutocompleteUserContactReplaceData {
     text?: string;
     userId: string;
     contact?: UserContact;
+    isEmailValid?: boolean;
 }
 export declare class AutocompleteGroup {
     id: string;

package/app/models/data/comment-actions.data.model.d.ts

@@ -85,6 +85,16 @@ export interface RejectCommentAnnotationRequest {
     annotationId: string;
     options?: RequestOptions;
 }
+export interface AcceptSuggestionRequest {
+    annotationId: string;
+    options?: RequestOptions;
+}
+export interface RejectSuggestionRequest {
+    annotationId: string;
+    /** Optional human-readable reason persisted on the suggestion. */
+    reason?: string;
+    options?: RequestOptions;
+}
 export interface DeleteCommentAnnotationRequest {
     annotationId: string;
     options?: RequestOptions;

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

@@ -7,6 +7,7 @@ import { CustomAnnotationDropdownItem } from "./custom-chip-dropdown.data.model"
 import { CustomCategory, CustomPriority, CustomStatus } from "./custom-filter.data.model";
 import { Location } from "./location.model";
 import { PageInfo } from "./page-info.model";
+import { SuggestionData } from "./suggestion.data.model";
 import { TargetElement } from "./target-element.data.model";
 import { TargetTextRange } from "./target-text-range.data.model";
 import { User } from "./user.data.model";
@@ -16,6 +17,34 @@ export interface CommentAnnotationVisibilityConfig {
     organizationId?: string;
     userIds?: string[];
 }
+/**
+ * Structured result produced by an AI agent for a comment annotation.
+ * Read-only from the SDK's perspective — written upstream by the agent.
+ */
+export interface AgentResult {
+    /** Short, bold headline rendered at the top of the agent suggestion card. */
+    title?: string;
+}
+/**
+ * Identity + output of the AI agent that authored a comment annotation.
+ * Present on annotations created by an agent. The agent-suggestion UI renders
+ * iff `agent` is present AND `type === 'suggestion'` (and the viewer is admin).
+ *
+ * `agentFields` mirrors the Firestore query field used by
+ * `CommentRequestQuery.agentFields` (see comment-actions.data.model.ts).
+ */
+export interface AgentData {
+    /** Canonical display name of the agent (card header). */
+    agentName?: string;
+    /** Legacy display name of the agent (card header); superseded by `agentName`. */
+    name?: string;
+    /** Avatar URL for the agent (card header); falls back to a default icon. */
+    avatar?: string;
+    /** Structured agent output (title, …). */
+    result?: AgentResult;
+    /** Queryable agent attributes. */
+    agentFields?: string[];
+}
 export declare class CommentAnnotation {
     /**
      * Unique identifier for the comment pin annotation.
@@ -150,6 +179,12 @@ export declare class CommentAnnotation {
     location?: Location | null;
     type?: string;
     commentType?: string;
+    /**
+     * Origin of the annotation. `'agent'` indicates the annotation was authored by
+     * an AI agent (drives the blue pin marker, agent identity header and blue text
+     * highlight). Absent / any other value indicates a regular user comment.
+     */
+    sourceType?: string;
     metadata?: CommentMetadata;
     /**
      * Selected text range of comment annotation
@@ -161,6 +196,10 @@ export declare class CommentAnnotation {
     selectAllContent?: boolean;
     approved?: boolean;
     status: CustomStatus;
+    /**
+     * User id of the user who updated the status of the comment annotation
+     */
+    statusUpdatedByUserId?: string | null;
     /**
      * To maintain index of current annotation in available list of annotations
      * It will start from 1, so no need to add 1 in that.
@@ -199,6 +238,30 @@ export declare class CommentAnnotation {
     viewedByUserIds?: string[];
     viewedBy?: User[];
     unread?: boolean;
+    /**
+     * SDK-managed suggestion data. Present iff type === 'suggestion'.
+     * Customer code must not write to this directly — use the SuggestionElement API.
+     *
+     * See docs/suggestions-api-contract.md for the full storage model.
+     */
+    suggestion?: SuggestionData;
+    /**
+     * AI agent identity + output. Present on agent-authored annotations.
+     * Read-only from the SDK; written upstream by the agent.
+     * See specs/agent-suggestion-comment-ui/spec.md (INV-001).
+     */
+    agent?: AgentData;
+    /**
+     * Server-derived set of all user IDs involved in this annotation
+     * (subscribed + unsubscribed participants). Written upstream; read-only
+     * from the SDK.
+     */
+    involvedUserIds?: string[];
+    /**
+     * Server-derived set of user IDs @mentioned across this annotation's
+     * comments. Written upstream; read-only from the SDK.
+     */
+    mentionedUserIds?: string[];
 }
 export declare class GhostComment {
     targetElement?: TargetElement | null;

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

@@ -67,6 +67,7 @@ export type CommentEventTypesMap = {
     [CommentEventTypes.UPDATE_ACCESS]: UpdateAccessEvent;
     [CommentEventTypes.RESOLVE_COMMENT]: ResolveCommentEvent;
     [CommentEventTypes.ADD_COMMENT]: AddCommentEvent;
+    [CommentEventTypes.ADD_COMMENT_DRAFT]: AddCommentDraftEvent;
     [CommentEventTypes.UPDATE_COMMENT]: UpdateCommentEvent;
     [CommentEventTypes.DELETE_COMMENT]: DeleteCommentEvent;
     [CommentEventTypes.ADD_ATTACHMENT]: AddAttachmentEvent;
@@ -92,6 +93,8 @@ export type CommentEventTypesMap = {
     [CommentEventTypes.COMMENT_SAVED]: CommentSavedEvent;
     [CommentEventTypes.COMMENT_SAVE_TRIGGERED]: CommentSaveTriggeredEvent;
     [CommentEventTypes.VISIBILITY_OPTION_CLICKED]: VisibilityOptionClickedEvent;
+    [CommentEventTypes.SUGGESTION_ACCEPTED]: SuggestionAcceptEvent;
+    [CommentEventTypes.SUGGESTION_REJECTED]: SuggestionRejectEvent;
 };
 export interface AddAttachmentEvent {
     annotationId: string;
@@ -145,6 +148,20 @@ export interface DeleteCommentAnnotationEvent {
     commentAnnotation: CommentAnnotation;
     metadata: VeltEventMetadata;
 }
+export interface SuggestionAcceptEvent {
+    annotationId: string;
+    commentAnnotation: CommentAnnotation;
+    metadata: VeltEventMetadata;
+    actionUser: User;
+}
+export interface SuggestionRejectEvent {
+    annotationId: string;
+    commentAnnotation: CommentAnnotation;
+    metadata: VeltEventMetadata;
+    actionUser: User;
+    /** Optional human-readable reason supplied at reject time. */
+    rejectReason?: string | null;
+}
 export interface GetCommentAnnotationsResponse {
     data: Record<string, CommentAnnotation[]> | null;
 }
@@ -181,6 +198,12 @@ export interface AddCommentEvent {
     comment: Comment;
     metadata: VeltEventMetadata;
 }
+export interface AddCommentDraftEvent {
+    annotationId: string;
+    commentAnnotation: CommentAnnotation;
+    comment: Comment;
+    metadata: VeltEventMetadata;
+}
 export interface CommentSavedEvent {
     annotationId: string;
     commentAnnotation: CommentAnnotation;

package/app/models/data/comment-sidebar-config.model.d.ts

@@ -1,3 +1,4 @@
+import { CommentAccessMode } from "../../utils/enums";
 import { CommentAnnotation } from "./comment-annotation.data.model";
 import { UnreadCommentsMap } from "./comment-utils.data.model";
 import { CustomFilters } from "./custom-filter.data.model";
@@ -64,6 +65,7 @@ export declare class CommentSidebarFilters {
     priority?: string[];
     status?: string[];
     category?: string[];
+    accessModes?: CommentAccessMode[];
     version?: {
         id: string;
         name?: string;

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

@@ -1,5 +1,6 @@
 import { Attachment } from "./attachment.model";
 import { AutocompleteGroupReplaceData, AutocompleteReplaceData, AutocompleteUserContactReplaceData } from "./autocomplete.data.model";
+import type { AgentData } from "./comment-annotation.data.model";
 import { ReactionAnnotation } from "./reaction-annotation.data.model";
 import { RecordedData } from "./recorder.model";
 import { User } from "./user.data.model";
@@ -88,4 +89,21 @@ export declare class Comment {
      */
     isEdited?: boolean;
     reactionAnnotations?: ReactionAnnotation[];
+    /**
+     * Origin of this individual comment. `'agent'` indicates the comment was
+     * authored by an AI agent (agent replies / multi-agent threads). Stamped
+     * server-side; mirrors `CommentAnnotation.sourceType` at the comment level.
+     */
+    sourceType?: string;
+    /**
+     * AI agent identity + output for an agent-authored comment. Present on
+     * per-comment agent replies. Read-only from the SDK; written upstream by the
+     * agent. Mirrors `CommentAnnotation.agent` at the comment level.
+     */
+    agent?: AgentData;
+    /**
+     * Customer-supplied metadata bag persisted as-is. Only present when a caller
+     * provides it; not server-generated.
+     */
+    metadata?: any;
 }

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

@@ -51,6 +51,7 @@ export declare class Config {
     advancedQueriesDisabled?: boolean;
     /**
      * The domain of the API proxy.
+     * @deprecated Use `proxyConfig.apiHost` instead.
      */
     apiProxyDomain?: string;
     /**
@@ -61,6 +62,26 @@ export declare class Config {
      * Default: true
      */
     globalStyles?: boolean;
+    /**
+     * Configuration for routing all traffic through reverse proxies.
+     */
+    proxyConfig?: ProxyConfig;
+}
+export interface ProxyConfig {
+    /** Custom host for the Velt CDN (e.g., 'cdn-proxy.customer.com') */
+    cdnHost?: string;
+    /** Custom host for the Velt API (e.g., 'api-proxy.customer.com') */
+    apiHost?: string;
+    /** Custom host for Firestore (e.g., 'firestore-proxy.customer.com') */
+    v2DbHost?: string;
+    /** Custom host for Firebase RTDB (e.g., 'rtdb-proxy.customer.com'). Replaces the firebaseio.com domain in all RTDB URLs. */
+    v1DbHost?: string;
+    /** Custom host for Firebase Storage (e.g., 'storage-proxy.customer.com'). Replaces firebasestorage.googleapis.com. */
+    storageHost?: string;
+    /** Custom host for Firebase Auth (e.g., 'auth-proxy.customer.com'). Replaces identitytoolkit.googleapis.com and securetoken.googleapis.com. */
+    authHost?: string;
+    /** Force long-polling for Firestore and RTDB instead of WebSocket. Default: false (WebSocket). */
+    forceLongPolling?: boolean;
 }
 export interface ExtendedFirebaseOptions extends FirebaseOptions {
     storeDbId: string;

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

@@ -9,6 +9,7 @@ export type CoreEventTypesMap = {
     [CoreEventTypes.REACTION_RESOLVER]: ReactionResolverEvent;
     [CoreEventTypes.RECORDER_RESOLVER]: RecorderResolverEvent;
     [CoreEventTypes.NOTIFICATION_RESOLVER]: NotificationResolverEvent;
+    [CoreEventTypes.ACTIVITY_RESOLVER]: ActivityResolverEvent;
     [CoreEventTypes.VELT_BUTTON_CLICK]: VeltButtonClickEvent;
     [CoreEventTypes.USER_UPDATE]: UserUpdateEvent;
     [CoreEventTypes.DOCUMENT_INIT]: DocumentInitEvent;
@@ -198,6 +199,26 @@ export type NotificationResolverEventType = {
     NOTIFICATION_DELETE_ERROR: 'notificationDeleteError';
 };
 export type NotificationResolverEvent = BaseResolverEvent<NotificationResolverEventType, NotificationResolverSource, NotificationResolverModuleName>;
+export declare enum ActivityResolverSource {
+    RESOLVE_ACTIVITIES = "resolveActivities",
+    SAVE_ACTIVITY = "saveActivity",
+    FORMAT_RESPONSE = "formatResponse"
+}
+export declare enum ActivityResolverModuleName {
+    GET_ACTIVITIES = "getActivities"
+}
+export type ActivityResolverEventType = {
+    ACTIVITY_RESOLUTION_REQUEST_FORMED: 'activityResolutionRequestFormed';
+    ACTIVITY_RESOLUTION_REQUEST_TRIGGERED: 'activityResolutionRequestTriggered';
+    ACTIVITY_RESOLUTION_RESULT: 'activityResolutionResult';
+    ACTIVITY_RESOLUTION_ERROR: 'activityResolutionError';
+    ACTIVITY_RESOLUTION_RESULT_FROM_CACHE: 'activityResolutionResultFromCache';
+    ACTIVITY_SAVE_REQUEST_FORMED: 'activitySaveRequestFormed';
+    ACTIVITY_SAVE_REQUEST_TRIGGERED: 'activitySaveRequestTriggered';
+    ACTIVITY_SAVE_RESULT: 'activitySaveResult';
+    ACTIVITY_SAVE_ERROR: 'activitySaveError';
+};
+export type ActivityResolverEvent = BaseResolverEvent<ActivityResolverEventType, ActivityResolverSource, ActivityResolverModuleName>;
 export type ErrorEvent = {
     event?: string;
     sourceMethod?: string;

package/app/models/data/document-paths.data.model.d.ts

@@ -6,6 +6,7 @@ export declare class DocumentPaths {
     folderId?: string;
     locationId?: string;
     allDocuments?: boolean;
+    optimisticPermissions?: boolean;
     veltFolderId?: string;
     folder?: string;
     /**

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

@@ -16,6 +16,8 @@ export interface SetDocumentsRequestOptions {
     locationId?: string;
     rootDocumentId?: string;
     context?: SetDocumentsContext;
+    debounceTime?: number;
+    optimisticPermissions?: boolean;
 }
 export interface UpdateDocumentsRequest<T = unknown> {
     organizationId?: string;

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

@@ -257,3 +257,23 @@ export interface NotificationsDocConfig {
 export interface GetNotificationsDataQuery {
     type?: 'all' | 'forYou' | 'documents';
 }
+/**
+ * Configuration for the opt-in cross-organization "For You" notifications feature.
+ *
+ * When enabled, the SDK merges notifications from other organizations the user
+ * belongs to (resolved from the global `userNotificationIndex`) into the existing
+ * "For You" feed. All fields are optional; sensible defaults are applied by
+ * `NotificationService.setCrossOrganizationConfig`.
+ *
+ * @see specs/notification-api-scope/spec.md
+ */
+export interface CrossOrganizationConfig {
+    /** Whether cross-organization notifications are active. Defaults to `true` on enable. */
+    enabled?: boolean;
+    /** Allowlist of organization IDs to include. When omitted, all indexed orgs are eligible. */
+    organizationIds?: string[];
+    /** Organization IDs to exclude. The current organization is always excluded. */
+    excludeOrganizationIds?: string[];
+    /** Feeds the merge applies to. Only `'forYou'` is supported; `'all'` is ignored with a warning. */
+    feeds?: ('forYou' | 'all')[];
+}

package/app/models/data/page-info.model.d.ts

@@ -47,4 +47,13 @@ export declare class PageInfo {
      */
     screenWidth?: number;
     deviceInfo?: IDeviceInfo;
+    /**
+     * @param applyClientOverride when true (default), merges the CURRENT document's client page
+     *        info override at construction time — covers the bare `new PageInfo()` sites
+     *        (cursor / presence / selection). No-op when the client hasn't provided any, so the
+     *        default empty-page-info behavior is unchanged. `getPageInfo(documentId)` passes
+     *        `false` so it can apply a specific document's override itself, without the current
+     *        document's fields leaking onto a different document's page info.
+     */
+    constructor(applyClientOverride?: boolean);
 }

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,3 +1,4 @@
+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";
@@ -12,4 +13,5 @@ export interface VeltDataProvider {
     anonymousUser?: AnonymousUserDataProvider;
     recorder?: RecorderAnnotationDataProvider;
     notification?: NotificationDataProvider;
+    activity?: ActivityAnnotationDataProvider;
 }

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

@@ -54,6 +54,11 @@ export declare class ReactionAnnotation {
     iconUrl?: string;
     iconEmoji?: string;
     metadata?: ReactionMetadata;
+    /**
+     * Server-derived set of all user IDs involved in this reaction annotation.
+     * Written upstream; read-only from the SDK.
+     */
+    involvedUserIds?: string[];
 }
 export declare class ReactionMetadata extends BaseMetadata {
     [key: string]: any;

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/rewriter-events.data.model.d.ts

@@ -0,0 +1,44 @@
+import { TargetTextRange } from './target-text-range.data.model';
+import { RewriterEventTypes } from '../../utils/enums';
+export type OpenAiModel = 'gpt-5.4' | 'gpt-5.4-pro' | 'gpt-5.4-mini' | 'gpt-5.4-nano' | 'gpt-5-mini' | 'gpt-5-nano' | 'gpt-5' | 'gpt-4.1' | 'gpt-4o' | 'gpt-4o-mini' | 'gpt-4-turbo' | 'o3-pro' | 'o3' | 'o3-mini' | 'o4-mini';
+export type AnthropicModel = 'claude-opus-4-6' | 'claude-sonnet-4-6' | 'claude-haiku-4-5' | 'claude-sonnet-4-5' | 'claude-opus-4-5' | 'claude-opus-4-1' | 'claude-sonnet-4-0' | 'claude-opus-4-0';
+export type GeminiModel = 'gemini-3.1-pro-preview' | 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite' | 'gemini-2.5-pro';
+export type AiModel = OpenAiModel | AnthropicModel | GeminiModel | (string & NonNullable<unknown>);
+export interface TextSelectedEvent {
+    selectionId: string;
+    text: string;
+    targetTextRange: TargetTextRange;
+}
+export interface RewriterAskAiRequest {
+    model: AiModel;
+    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/suggestion-events.data.model.d.ts

@@ -0,0 +1,57 @@
+import { SuggestionEventTypes } from '../../utils/enums';
+import { ApprovedSuggestion, PendingSuggestion, RejectedSuggestion, StaleSuggestion, TargetEditCommitBuilder, TargetEditDetails } from './suggestion.data.model';
+/**
+ * Public payload types for the v1 Suggestions feature. Mirrors the layout of
+ * `comment-events.data.model.ts` and `recorder-events.data.model.ts`:
+ *
+ *   - One named interface per event payload.
+ *   - One `SuggestionEventTypesMap` keyed by `SuggestionEventTypes` enum values.
+ *
+ * Customers pass an event-name string (or the enum constant — they're
+ * equivalent) to `velt.getSuggestionElement().on(...)` and receive an
+ * `Observable<SuggestionEventTypesMap[T]>`.
+ *
+ * No separate `actor`/`user` field on the payloads: the user info is on
+ * `suggestion.createdBy` (for created) and `suggestion.resolvedBy` (for
+ * approved/rejected/stale). Matches the comment-event shape.
+ */
+export interface SuggestionCreatedEvent {
+    suggestion: PendingSuggestion;
+    timestamp: number;
+}
+export interface SuggestionApprovedEvent {
+    suggestion: ApprovedSuggestion;
+    timestamp: number;
+}
+export interface SuggestionRejectedEvent {
+    suggestion: RejectedSuggestion;
+    timestamp: number;
+}
+export interface SuggestionStaleEvent {
+    suggestion: StaleSuggestion;
+    timestamp: number;
+}
+export interface TargetEditStartEvent {
+    details: TargetEditDetails;
+    timestamp: number;
+}
+export interface TargetEditCommitEvent {
+    details: TargetEditDetails;
+    /**
+     * Pre-bound builder. Calling it commits the suggestion using the SDK's
+     * default summary/metadata, optionally overridden by `result`. If the
+     * customer's `onTargetEditCommit` handler already returned a non-null
+     * result for this edit, this builder is a no-op so subscribers can't
+     * double-commit.
+     */
+    commitSuggestion: TargetEditCommitBuilder;
+    timestamp: number;
+}
+export type SuggestionEventTypesMap = {
+    [SuggestionEventTypes.SUGGESTION_CREATED]: SuggestionCreatedEvent;
+    [SuggestionEventTypes.SUGGESTION_APPROVED]: SuggestionApprovedEvent;
+    [SuggestionEventTypes.SUGGESTION_REJECTED]: SuggestionRejectedEvent;
+    [SuggestionEventTypes.SUGGESTION_STALE]: SuggestionStaleEvent;
+    [SuggestionEventTypes.TARGET_EDIT_START]: TargetEditStartEvent;
+    [SuggestionEventTypes.TARGET_EDIT_COMMIT]: TargetEditCommitEvent;
+};