@veltdev/sdk-staging 5.0.2-beta.8 → 5.0.2-beta.80

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;
@@ -76,4 +97,9 @@ export interface DisableLogsConfig {
 }
 export interface GetProjectConfigResponse {
     isPrivateCommentsEnabled: boolean;
+    activityConfig?: ActivityConfig;
+}
+export interface ActivityConfig {
+    immutable: boolean;
+    isEnabled: boolean;
 }

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

@@ -7,6 +7,9 @@ export type CoreEventTypesMap = {
     [CoreEventTypes.COMMENT_RESOLVER]: CommentResolverEvent;
     [CoreEventTypes.ATTACHMENT_RESOLVER]: AttachmentResolverEvent;
     [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;
@@ -23,7 +26,8 @@ export declare enum UserResolverSource {
     SET_SINGLE_EDITOR_MODE_LIVE_STATE_DATA_FOR_DIFFERENT_USER_PRESENT_ON_TAB = "setSingleEditorModeLiveStateDataForDifferentUserPresentOnTab",
     RESOLVE_AND_MERGE_SINGLE_EDITOR_LIVE_STATE_DATA_WITH_USER = "resolveAndMergeSingleEditorLiveStateDataWithUser",
     GET_SINGLE_EDITOR_MODE_DATA = "getSingleEditorModeData",
-    RESOLVE_USERS_FROM_HUDDLE_MESSAGES = "resolveUsersFromHuddleMessages"
+    RESOLVE_USERS_FROM_HUDDLE_MESSAGES = "resolveUsersFromHuddleMessages",
+    RESOLVE_USER_IDS_BY_EMAIL = "resolveUserIdsByEmail"
 }
 export declare enum UserResolverModuleName {
     IDENTIFY = "identify/authProvider",
@@ -146,6 +150,75 @@ export type ReactionResolverEventType = {
     REACTION_DELETE_RESULT: 'reactionDeleteResult';
     REACTION_DELETE_ERROR: 'reactionDeleteError';
 };
+export declare enum RecorderResolverSource {
+    RESOLVE_RECORDER_ANNOTATIONS = "resolveRecorderAnnotations",
+    SAVE_RECORDER_ANNOTATION = "saveRecorderAnnotation",
+    DELETE_RECORDER_ANNOTATION = "deleteRecorderAnnotation",
+    FORMAT_RESPONSE = "formatResponse",
+    INIT_DOCUMENTS = "initDocuments",
+    SET_DATA = "setData",
+    UPDATE_DATA = "updateData",
+    DELETE_DATA = "deleteData"
+}
+export declare enum RecorderResolverModuleName {
+    GET_RECORDER_ANNOTATIONS = "getRecorderAnnotations"
+}
+export type RecorderResolverEvent = BaseResolverEvent<RecorderResolverEventType, RecorderResolverSource, RecorderResolverModuleName>;
+export type RecorderResolverEventType = {
+    RECORDER_RESOLUTION_REQUEST_FORMED: 'recorderResolutionRequestFormed';
+    RECORDER_RESOLUTION_REQUEST_TRIGGERED: 'recorderResolutionRequestTriggered';
+    RECORDER_RESOLUTION_RESULT: 'recorderResolutionResult';
+    RECORDER_RESOLUTION_ERROR: 'recorderResolutionError';
+    RECORDER_RESOLUTION_RESULT_FROM_CACHE: 'recorderResolutionResultFromCache';
+    RECORDER_SAVE_REQUEST_FORMED: 'recorderSaveRequestFormed';
+    RECORDER_SAVE_REQUEST_TRIGGERED: 'recorderSaveRequestTriggered';
+    RECORDER_SAVE_RESULT: 'recorderSaveResult';
+    RECORDER_SAVE_ERROR: 'recorderSaveError';
+    RECORDER_DELETE_REQUEST_FORMED: 'recorderDeleteRequestFormed';
+    RECORDER_DELETE_REQUEST_TRIGGERED: 'recorderDeleteRequestTriggered';
+    RECORDER_DELETE_RESULT: 'recorderDeleteResult';
+    RECORDER_DELETE_ERROR: 'recorderDeleteError';
+};
+export declare enum NotificationResolverSource {
+    RESOLVE_NOTIFICATIONS = "resolveNotifications",
+    DELETE_NOTIFICATION = "deleteNotification",
+    DELETE_DATA = "deleteData",
+    FORMAT_RESPONSE = "formatResponse"
+}
+export declare enum NotificationResolverModuleName {
+    GET_NOTIFICATIONS = "getNotifications"
+}
+export type NotificationResolverEventType = {
+    NOTIFICATION_RESOLUTION_REQUEST_FORMED: 'notificationResolutionRequestFormed';
+    NOTIFICATION_RESOLUTION_REQUEST_TRIGGERED: 'notificationResolutionRequestTriggered';
+    NOTIFICATION_RESOLUTION_RESULT: 'notificationResolutionResult';
+    NOTIFICATION_RESOLUTION_ERROR: 'notificationResolutionError';
+    NOTIFICATION_DELETE_REQUEST_FORMED: 'notificationDeleteRequestFormed';
+    NOTIFICATION_DELETE_REQUEST_TRIGGERED: 'notificationDeleteRequestTriggered';
+    NOTIFICATION_DELETE_RESULT: 'notificationDeleteResult';
+    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/crdt.data.model.d.ts

@@ -58,3 +58,54 @@ export interface CrdtDeleteVersionQuery {
     id: string;
     versionId: string;
 }
+export interface CrdtPushMessageQuery {
+    id: string;
+    data: number[];
+    yjsClientId: number;
+    messageType?: 'sync' | 'awareness';
+    /** User-facing value for event emission only (not stored in database) */
+    eventData?: unknown;
+    /** Yjs data type: 'text' | 'map' | 'array' | 'xml' | 'xmltext' */
+    type?: string;
+    /** Content key used in Y.Doc shared types */
+    contentKey?: string;
+    /** Editor/library source: 'tiptap', 'plate', 'codemirror', etc. */
+    source?: string;
+}
+export interface CrdtOnMessageQuery {
+    id: string;
+    callback: (message: CrdtMessageData) => void;
+    afterTs?: number;
+}
+export interface CrdtMessageData {
+    data: number[];
+    yjsClientId: number;
+    timestamp: number;
+}
+export interface CrdtSnapshotData {
+    state?: Uint8Array | number[];
+    vector?: Uint8Array | number[];
+    timestamp?: number;
+}
+export interface CrdtGetSnapshotQuery {
+    id: string;
+}
+export interface CrdtSaveSnapshotQuery {
+    id: string;
+    state: Uint8Array | number[];
+    vector: Uint8Array | number[];
+    /** Yjs data type: 'text' | 'map' | 'array' | 'xml' | 'xmltext' */
+    type?: string;
+    /** Content key used in Y.Doc shared types */
+    contentKey?: string;
+    /** Editor/library source: 'tiptap', 'plate', 'codemirror', etc. */
+    source?: string;
+}
+export interface CrdtGetMessagesQuery {
+    id: string;
+    afterTs?: number;
+}
+export interface CrdtPruneMessagesQuery {
+    id: string;
+    beforeTs: number;
+}

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

@@ -5,12 +5,18 @@ export interface AccessRequestEvent {
     editor?: User;
     timestamp?: number;
     status?: string;
+    totalUsers?: number;
+    presenceSnippylyUserIds?: string[];
+    presenceClientUserIds?: string[];
 }
 export interface SEMEvent {
     viewer?: User;
     editor?: User;
     timestamp?: number;
     role?: string;
+    totalUsers?: number;
+    presenceSnippylyUserIds?: string[];
+    presenceClientUserIds?: string[];
 }
 export type LiveStateEventTypesMap = {
     [LiveStateSyncEventTypes.ACCESS_REQUESTED]: AccessRequestEvent;

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,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;
+};