@veltdev/sdk-staging 6.0.0-beta.2 → 6.0.0-beta.20

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

@@ -1,9 +1,8 @@
-// @ts-nocheck
 import { Observable } from "rxjs";
 import { Config, DisableLogsConfig } from "../models/data/config.data.model";
 import { DocumentUser } from "../models/data/document-user.data.model";
 import { Location } from "../models/data/location.model";
-import { User, UserOptions, VeltAuthProvider, VeltPermissionProvider } from "../models/data/user.data.model";
+import { User, Options, VeltAuthProvider, VeltPermissionProvider } from "../models/data/user.data.model";
 import { CustomCss } from "../models/data/custom-css.data.model";
 import { ActivityElement } from "../models/element/activity-element.model";
 import { AreaElement } from "../models/element/area-element.model";
@@ -40,7 +39,7 @@ import { HeartbeatConfig, Heartbeat, GetHeartbeatResponse } from "../models/data
 export declare class Snippyly {
    constructor();
    initConfig: (apiKey: string, config?: Config) => void;
-   identify: (user: User, userOptions?: UserOptions) => Promise<unknown>;
+   identify: (user: User, userOptions?: Options) => Promise<unknown>;
    setVeltAuthProvider: (veltAuthProvider: VeltAuthProvider) => Promise<User | null>;
    /**
     * Tell us who the currently logged in user is.
@@ -284,6 +283,16 @@ export declare class Snippyly {
     */
    setDarkMode: (darkMode: boolean) => void;
 
+   /**
+    * Removes (or restores) ALL Velt visual styling at once — headless mode.
+    * By default a derived "functional-only" layer is kept so Velt UI retains
+    * its layout, positioning and show/hide behavior. Pass
+    * `keepFunctionalStyles: false` for total removal. Fully reversible.
+    * @param value {boolean} true = unstyled, false = styled (default)
+    * @param config {object} { keepFunctionalStyles?: boolean } defaults to true
+    */
+   setUnstyledMode: (value: boolean, config?: { keepFunctionalStyles?: boolean }) => void;
+
    /**
     * To check if user allowed in provided document or not.
     */

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

@@ -89,6 +89,11 @@ export type CommentEventTypesMap = {
     [CommentEventTypes.COMMENT_TOOL_CLICKED]: CommentToolClickedEvent;
     [CommentEventTypes.SIDEBAR_BUTTON_CLICK]: SidebarButtonClickEvent;
     [CommentEventTypes.SIDEBAR_BUTTON_CLICKED]: SidebarButtonClickedEvent;
+    [CommentEventTypes.SIDEBAR_OPEN]: SidebarOpenEvent;
+    [CommentEventTypes.SIDEBAR_CLOSE]: SidebarCloseEvent;
+    [CommentEventTypes.FULLSCREEN_CLICK]: FullscreenClickEvent;
+    [CommentEventTypes.COMMENT_CLICK]: CommentClickEvent;
+    [CommentEventTypes.COMMENT_NAVIGATION_BUTTON_CLICK]: CommentNavigationButtonClickEvent;
     [CommentEventTypes.ATTACHMENT_DOWNLOAD_CLICKED]: AttachmentDownloadClickedEvent;
     [CommentEventTypes.COMMENT_SAVED]: CommentSavedEvent;
     [CommentEventTypes.COMMENT_SAVE_TRIGGERED]: CommentSaveTriggeredEvent;
@@ -347,6 +352,40 @@ export interface SidebarButtonClickEvent {
 }
 export interface SidebarButtonClickedEvent extends SidebarButtonClickEvent {
 }
+/** Fired when the comment sidebar opens. Subscribe via `commentElement.on('sidebarOpen')`. */
+export interface SidebarOpenEvent {
+    metadata?: VeltEventMetadata;
+}
+/** Fired when the comment sidebar closes. Subscribe via `commentElement.on('sidebarClose')`. */
+export interface SidebarCloseEvent {
+    metadata?: VeltEventMetadata;
+}
+/**
+ * Fired when the sidebar fullscreen toggle is clicked. Subscribe via
+ * `commentElement.on('fullscreenClick')`. `fullScreen` is the NEW state after the toggle.
+ * (Also surfaced as the `onFullscreenClick` @Output on the sidebar component.)
+ */
+export interface FullscreenClickEvent {
+    fullScreen: boolean;
+    metadata?: VeltEventMetadata;
+}
+/** Fired when a comment is clicked in the sidebar list. Subscribe via `commentElement.on('commentClick')`. */
+export interface CommentClickEvent {
+    documentId?: string | null;
+    location?: Location | null;
+    targetElementId?: string | null;
+    context?: {
+        [key: string]: any;
+    };
+    annotation?: CommentAnnotation;
+    metadata?: VeltEventMetadata;
+}
+/**
+ * Fired when the navigation ("go to") button on a sidebar comment is clicked.
+ * Subscribe via `commentElement.on('commentNavigationButtonClick')`.
+ */
+export interface CommentNavigationButtonClickEvent extends CommentClickEvent {
+}
 export interface AttachmentDownloadClickedEvent {
     annotationId: string;
     commentAnnotation: CommentAnnotation;

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

@@ -66,6 +66,160 @@ export declare class Config {
      * Configuration for routing all traffic through reverse proxies.
      */
     proxyConfig?: ProxyConfig;
+    /**
+     * Self-hosting / on-prem backend configuration. When set, a deployment can point
+     * Velt-infra endpoints (Firebase config, cloud-function URLs, the notifications-hub
+     * RTDB URL, the regional setEncryptedData endpoints) at the customer's own infra.
+     *
+     * Every field is OPTIONAL and every unspecified value falls back to the per-build
+     * default in `src/environments/*` — so an existing SaaS build with no `selfHosted`
+     * config behaves exactly as before (behavior-preserving).
+     */
+    selfHosted?: SelfHostedConfig;
+}
+/**
+ * VENDORED from the backend deployment-profile manifest — source of truth:
+ * `shared-firebase-function` repo, `functions/src/deployment-profiles/modules.manifest.ts`
+ * (`DeploymentModuleId`, 12 modules; backend plan §8.3; restructured 2026-07-10 in backend
+ * iteration-10, owner-directed). Do NOT add, remove, or rename ids here without a matching
+ * manifest change — the endpoint→module map in `endpoints.service.ts` and its cross-repo
+ * drift-fence test key off this list.
+ *
+ * 2026-07-10 restructure summary:
+ * - DELETED (absorbed into `core`): `notifications`, `analytics-telemetry`, `console`.
+ *   The agents RUNTIME also moved to `core` (`agents` keeps only the approval engine).
+ * - NEW `rest-api`: the customer-facing REST CFs (`commentsapibe`, `documentsapibe`, …),
+ *   now opt-in (hardDep `core`). None of the SDK's own runtime endpoints live there.
+ * - NEW `legacy-v1`: the ~55 standalone V1 REST CFs — EXCLUDED, never provisioned on any
+ *   self-hosted profile, so this id never appears in a valid `deploymentProfile`.
+ * - `core` is the SOLE mandatory module.
+ */
+export declare const DEPLOYMENT_MODULE_IDS: readonly ["core", "rest-api", "recorder-media", "ai", "agents", "huddle-webrtc", "integrations-workflow", "superflow", "billing-stripe", "migrations", "legacy-v1", "velt-internal"];
+/** A backend feature-module id (see {@link DEPLOYMENT_MODULE_IDS} for provenance). */
+export type DeploymentModuleId = typeof DEPLOYMENT_MODULE_IDS[number];
+/**
+ * Per-endpoint overrides for the cloud-function fleet. Each value is a fully-configurable
+ * ABSOLUTE base URL — do NOT assume the `*.cloudfunctions.net` shape (Tier A now serves the
+ * fleet from Cloud Run with arbitrary hostnames). Keys mirror `environment.cloudFunction.*`.
+ * Unspecified keys fall back to the `environment` default.
+ */
+export interface SelfHostedCloudFunctionConfig {
+    validateClient?: string;
+    getPlanDetails?: string;
+    sa?: string;
+    getIceServers?: string;
+    chatgptCompletion?: string;
+    rewriterAskAi?: string;
+    whisperTranscription?: string;
+    getAllowedDocuments?: string;
+    getNotificationsForDocuments?: string;
+    videoBackend?: string;
+    convertRecording?: string;
+    processRecording?: string;
+    sdkProxy?: string;
+    screenshot?: string;
+    /**
+     * Single override for the write endpoint that collapses the ×5 regional
+     * `setEncryptedData` split — when set, it is used for ALL regions. Self-hosted
+     * deployments typically run a single region.
+     */
+    setEncryptedData?: string;
+    /**
+     * Optional per-region overrides (used only if the single `setEncryptedData` above is
+     * unset). Keys are the `FirebaseRegion` values (`usCentral1`, `asiaSouthEast1`, ...).
+     */
+    regions?: {
+        [region: string]: {
+            setEncryptedData?: string;
+        };
+    };
+}
+export interface SelfHostedConfig {
+    /**
+     * Strict (full self-hosted) mode. Default `false`.
+     *
+     * - `false` (hybrid / staged rollout): any endpoint WITHOUT an injected override falls
+     *   back to the Velt default in `src/environments/*` — useful for testing one
+     *   self-hosted endpoint at a time while the rest stay on Velt SaaS.
+     * - `true` (full self-hosting / data sovereignty): there is NO fallback to Velt. An
+     *   endpoint without an injected override resolves to an inert
+     *   `velt://self-hosted-disabled/<endpoint>` sentinel that can never produce network
+     *   egress — the feature behind it is effectively disabled. Missing CORE endpoints
+     *   (`validateClient`, `sdkProxy`, `setEncryptedData`, `getNotificationsForDocuments`,
+     *   the notifications DB URL, `firebaseConfig`) are additionally
+     *   reported once as a loud misconfiguration error, since the SDK cannot function
+     *   without them (plan §4.3: every endpoint runs in the customer cloud or is disabled).
+     */
+    strict?: boolean;
+    /**
+     * Firebase config override (deep-merged over `environment.firebaseConfig`). Injected
+     * keys win; unspecified keys keep the `environment` default. Per-tenant auth-token
+     * claims still override this at runtime (within-project tenant routing is preserved).
+     *
+     * NOTE (strict mode): this is the ONE value that still falls back to the `environment`
+     * default when unset, because an undefined base config would break the Firebase
+     * bootstrap chain outright. The miss is still reported as a core misconfiguration, and
+     * the `identify()` response config overrides this base at runtime anyway. Making the
+     * bootstrap itself injectable is the tracked Phase A gap (`app.module.ts` static
+     * `initializeApp`).
+     */
+    firebaseConfig?: Partial<FirebaseOptions>;
+    /** Override for the notifications-hub RTDB URL (`firebaseNotificationsDatabaseURL`). */
+    firebaseNotificationsDatabaseURL?: string;
+    /** Per-endpoint cloud-function URL overrides. */
+    cloudFunction?: SelfHostedCloudFunctionConfig;
+    /**
+     * Enables defensive consumption of the portable-backend `identify()` response
+     * (`{ token, backend, wsEndpoint, apiEndpoint }`, backend §6.1). Default `false`:
+     * when false, a portable response is ignored and the existing Firebase path runs
+     * unchanged — no behavior change when the backend does not send it.
+     */
+    enablePortableBackend?: boolean;
+    /**
+     * The RESOLVED module closure of the deployment profile (backend plan §8.3) — the
+     * enabled-module-id list the backend deploy tooling emits in
+     * `velt-deployment-profile.json`. The customer's tooling inlines it at init; the SDK
+     * does NOT fetch it at runtime and does NOT re-resolve module dependencies (the
+     * backend's `profile-resolver.ts` already computed the fail-closed closure).
+     *
+     * Semantics (ratified — SDK-side synthesis, no Tier A server router):
+     * - Absent, not an array, or an EMPTY array (a valid resolved closure is never empty):
+     *   ALL modules enabled — byte-identical to today for SaaS and existing selfHosted
+     *   configs.
+     * - Non-empty: LITERAL membership — any endpoint whose module is NOT in the list
+     *   resolves to the inert `velt://self-hosted-disabled/*` sentinel, so the denial
+     *   normalizer synthesizes `'unimplemented'` locally with zero egress. Works with or
+     *   without `strict`. Unknown/typo'd ids enable nothing (fail-closed, mirroring the
+     *   backend resolver — a malformed profile must not silently re-open Velt egress).
+     * - A profile opt-out is authoritative: it wins over an injected endpoint URL, and its
+     *   endpoints degrade silently even when classified `core` (opt-out ≠ misconfiguration
+     *   — they are excluded from the strict-mode core-misconfiguration report).
+     */
+    deploymentProfile?: DeploymentModuleId[];
+    /**
+     * The `dataRegions` field of the `velt-deployment-profile.json` v1 document (additive
+     * 2026-07-10, GTK-005-safe): which regional `setencrypteddata*` variants the deployment
+     * provisioned. Inlined by the customer's tooling alongside {@link deploymentProfile}.
+     *
+     * - `undefined` / `null` — no region filter (all regional variants provisioned; the
+     *   SaaS shape). `null` and `[]` are DIFFERENT fleets — never coalesce them.
+     * - `[]` — ONLY the base `setencrypteddata` (in the deployment's own region) exists.
+     * - `['europe-west1', …]` — the base plus the variants for exactly those GCP regions
+     *   (known: `europe-west1`, `asia-southeast1`, `australia-southeast1`,
+     *   `asia-northeast1`).
+     *
+     * The SDK uses this as a pre-call provisioning check in
+     * `EndpointsService.getSetEncryptedDataUrl`: a tenant routed to an UNPROVISIONED
+     * regional variant degrades to the base `setEncryptedData` resolution instead of
+     * calling a URL that would 404.
+     *
+     * The filter is AUTHORITATIVE over injected per-region URLs (mirroring how a
+     * `deploymentProfile` opt-out wins over an injected endpoint URL): an injected
+     * `cloudFunction.regions[X]` override for a region excluded by `dataRegions` is
+     * never consulted — the write resolves through the base slot. Don't inject overrides
+     * for regions the deployment did not provision.
+     */
+    dataRegions?: string[] | null;
 }
 export interface ProxyConfig {
     /** Custom host for the Velt CDN (e.g., 'cdn-proxy.customer.com') */

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

@@ -39,4 +39,5 @@ export interface PartialReactionAnnotation {
     metadata?: BaseMetadata;
     icon?: string;
     from?: PartialUser;
+    [key: string]: any;
 }

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

@@ -21,14 +21,16 @@ export declare class Selection {
     pageInfo: PageInfo;
     timestamp: number;
 }
-export declare enum UserIndicatorPosition {
-    Start = "start",
-    End = "end"
-}
-export declare enum UserIndicatorType {
-    Avatar = "avatar",
-    Label = "label"
-}
+export declare const UserIndicatorPosition: {
+    readonly Start: "start";
+    readonly End: "end";
+};
+export type UserIndicatorPosition = (typeof UserIndicatorPosition)[keyof typeof UserIndicatorPosition];
+export declare const UserIndicatorType: {
+    readonly Avatar: "avatar";
+    readonly Label: "label";
+};
+export type UserIndicatorType = (typeof UserIndicatorType)[keyof typeof UserIndicatorType];
 export declare class LiveSelectionData {
     [userIdHash: string]: Selection;
 }

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

@@ -61,12 +61,14 @@ export interface GetUserPermissionsResponse {
         };
     };
 }
-export declare enum UserPermissionAccessRole {
-    EDITOR = "editor",
-    VIEWER = "viewer"
-}
-export declare enum UserPermissionAccessRoleResult {
-    DOES_NOT_EXIST = "does_not_exist",
-    PERMISSION_DENIED = "permission_denied",
-    SOMETHING_WENT_WRONG = "something_went_wrong"
-}
+export declare const UserPermissionAccessRole: {
+    readonly EDITOR: "editor";
+    readonly VIEWER: "viewer";
+};
+export type UserPermissionAccessRole = (typeof UserPermissionAccessRole)[keyof typeof UserPermissionAccessRole];
+export declare const UserPermissionAccessRoleResult: {
+    readonly DOES_NOT_EXIST: "does_not_exist";
+    readonly PERMISSION_DENIED: "permission_denied";
+    readonly SOMETHING_WENT_WRONG: "something_went_wrong";
+};
+export type UserPermissionAccessRoleResult = (typeof UserPermissionAccessRoleResult)[keyof typeof UserPermissionAccessRoleResult];

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

@@ -125,18 +125,20 @@ export interface VeltAuthProvider {
     generateToken?: () => Promise<string>;
     onError?: (err: unknown) => void;
 }
-export declare enum RevokeAccessOnType {
-    DOCUMENT_UNSET = "document_unset",
-    USER_LOGOUT = "user_logout"
-}
-export declare enum PermissionSource {
-    SET_DOCUMENTS = "setDocuments",
-    IDENTIFY = "identify",
-    GET_NOTIFICATIONS = "getNotifications",
-    SET_NOTIFICATIONS = "setNotifications",
-    REVOKE_ACCESS_ON_USER_LOGOUT = "revokeAccessOnUserLogout",
-    REVOKE_ACCESS_ON_DOCUMENT_UNSET = "revokeAccessOnDocumentUnset"
-}
+export declare const RevokeAccessOnType: {
+    readonly DOCUMENT_UNSET: "document_unset";
+    readonly USER_LOGOUT: "user_logout";
+};
+export type RevokeAccessOnType = (typeof RevokeAccessOnType)[keyof typeof RevokeAccessOnType];
+export declare const PermissionSource: {
+    readonly SET_DOCUMENTS: "setDocuments";
+    readonly IDENTIFY: "identify";
+    readonly GET_NOTIFICATIONS: "getNotifications";
+    readonly SET_NOTIFICATIONS: "setNotifications";
+    readonly REVOKE_ACCESS_ON_USER_LOGOUT: "revokeAccessOnUserLogout";
+    readonly REVOKE_ACCESS_ON_DOCUMENT_UNSET: "revokeAccessOnDocumentUnset";
+};
+export type PermissionSource = (typeof PermissionSource)[keyof typeof PermissionSource];
 export interface RevokeAccessOn {
     type: RevokeAccessOnType;
     revokeOrganizationAccess?: boolean;
@@ -192,12 +194,13 @@ export interface PermissionResolverRequest {
         requests: PermissionQuery[];
     };
 }
-export declare enum PermissionResourceType {
-    FOLDER = "folder",
-    DOCUMENT = "document",
-    ORGANIZATION = "organization",
-    CONTEXT = "context"
-}
+export declare const PermissionResourceType: {
+    readonly FOLDER: "folder";
+    readonly DOCUMENT: "document";
+    readonly ORGANIZATION: "organization";
+    readonly CONTEXT: "context";
+};
+export type PermissionResourceType = (typeof PermissionResourceType)[keyof typeof PermissionResourceType];
 export interface PermissionQuery {
     userId: string;
     resource: {

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { Observable } from "rxjs";
 import { ActivityRecord, ActivitySubscribeConfig, CreateActivityData } from "../data/activity.data.model";
 

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 export declare class AreaElement {
     /**
      * To enable area feature

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

@@ -1,10 +1,9 @@
-// @ts-nocheck
 export declare class ArrowElement {
     /**
      * To allow arrow in specific elements only
      * @param elementIds Element ids to be allowed for arrow
      */
-    public allowedElementIds: (elementIds: string[]) => any;
+    public allowedElementIds: (elementIds: string[]) => void;
 
     constructor();
 

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { Observable } from "rxjs";
 import { AutocompleteData, AutocompleteChipData } from "../data/autocomplete.data.model";
 export declare class AutocompleteElement {