@parall/sdk 1.48.0 → 1.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/sdk",
-  "version": "1.48.0",
+  "version": "1.49.0",
   "description": "TypeScript client SDK for Parall — REST + WebSocket client, shared types",
   "license": "MIT",
   "repository": {

package/src/client.ts

@@ -167,6 +167,8 @@ import type {
   DispatchExpireResult,
   ResolveRefsResponse,
   BacklinksResponse,
+  OutboundRefsRequest,
+  OutboundRefsResponse,
   RefGraphResponse,
   BrokenRefsResponse,
   PushSubscribeRequest,
@@ -223,14 +225,20 @@ import type {
   BrowserProfileLifecycleRequest,
   BrowserViewerCommandRequest,
   BrowserViewerCommandResponse,
+  EdgeViewerCommandRequest,
+  EdgeViewerCommandResponse,
   GrantBrowserProfileConsentRequest,
   EdgeDevice,
   EdgePlacement,
   EdgeBrowserProfile,
+  EdgeProfileProxyStatus,
+  SetEdgeProfileProxyRequest,
   ClipConnection,
   EdgeOnboardingStatus,
   ExecEdgeClipRequest,
   EdgeClipExecResult,
+  ReactionSummary,
+  ToggleReactionResponse,
 } from './types.js';
 
 export interface ParallClientOptions {
@@ -421,6 +429,8 @@ export class ParallClient {
       timeoutMs?: number;
       signal?: AbortSignal;
       keepalive?: boolean;
+      /** Additional request preconditions such as If-Match. */
+      headers?: Record<string, string>;
       /** Observes the final HTTP status of a successful request (e.g. 200-idempotent-replay vs 201-created). */
       onStatus?: (status: number) => void;
     },
@@ -443,7 +453,7 @@ export class ParallClient {
       if (qs) url += `?${qs}`;
     }
 
-    const headers = this.buildHeaders(path);
+    const headers = this.buildHeaders(path, opts?.headers);
 
     // Cancellation: the caller's AbortSignal (e.g. a superseded search query)
     // races the per-request timeout. AbortSignal.any aborts as soon as either
@@ -1095,6 +1105,20 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.MESSAGE_REPLIES(id), undefined, params);
   }
 
+  // ---- Reactions ----
+
+  async toggleReaction(messageId: string, emoji: string): Promise<ToggleReactionResponse> {
+    return this.request('PUT', ENDPOINTS.MESSAGE_REACTION(messageId, emoji));
+  }
+
+  async listReactions(messageId: string): Promise<ReactionSummary[]> {
+    const res = await this.request<{ reactions: ReactionSummary[] }>(
+      'GET',
+      ENDPOINTS.MESSAGE_REACTIONS(messageId),
+    );
+    return res.reactions;
+  }
+
   // ---- File Upload ----
 
   async getUploadPresignUrl(orgId: string, req: PresignUploadRequest): Promise<PresignResponse> {
@@ -1757,6 +1781,28 @@ export class ParallClient {
     );
   }
 
+  /**
+   * Drive the Cloud Edge live viewer (V1b, design §6): WebRTC signaling + input +
+   * tab nav for a hosted browser (Cloud Profile). Same request/reply shape as
+   * browserViewerCommand, on the v3 edge pipe; additive — the v2 browser-profile
+   * viewer is unchanged.
+   */
+  async edgeViewerCommand(
+    orgId: string,
+    edgeId: string,
+    req: EdgeViewerCommandRequest,
+    opts?: { timeoutMs?: number; keepalive?: boolean },
+  ): Promise<EdgeViewerCommandResponse> {
+    return this.request(
+      'POST',
+      ENDPOINTS.ORG_EDGE_VIEWER_COMMAND(orgId, edgeId),
+      req,
+      undefined,
+      false,
+      opts,
+    );
+  }
+
   async resizeMachine(
     orgId: string,
     machineId: string,
@@ -1813,9 +1859,23 @@ export class ParallClient {
 
   // ---- Unread ----
 
-  async getUnreadCounts(orgId?: string): Promise<Record<string, UnreadEntry>> {
+  async getUnreadCounts(
+    orgId?: string,
+    opts?: {
+      /** Add unread thread replies (per-thread cursors) to count/mentions.
+       *  Opt-in: only clients that can clear thread cursors should pass it. */
+      includeThreadReplies?: boolean;
+    },
+  ): Promise<Record<string, UnreadEntry>> {
     const endpoint = orgId ? ENDPOINTS.ORG_UNREAD(orgId) : ENDPOINTS.UNREAD;
-    const res = await this.request<{ data: Record<string, UnreadEntry> }>('GET', endpoint);
+    const res = await this.request<{ data: Record<string, UnreadEntry> }>(
+      'GET',
+      endpoint,
+      undefined,
+      {
+        include_thread_replies: opts?.includeThreadReplies ? 'true' : undefined,
+      },
+    );
     return res.data;
   }
 
@@ -1823,6 +1883,14 @@ export class ParallClient {
     return this.request('POST', ENDPOINTS.CHAT_READ(orgId, chatId), { message_id: messageId });
   }
 
+  /** Mark everything in a chat read: the channel cursor jumps to the latest
+   *  top-level message and every thread cursor to its latest reply, in one
+   *  idempotent call. The server echoes the same per-cursor WS events the
+   *  single-cursor routes emit and auto-clears covered inbox items. */
+  async markAllRead(orgId: string, chatId: string): Promise<void> {
+    return this.request('POST', ENDPOINTS.CHAT_READ_ALL(orgId, chatId));
+  }
+
   async getThreadUnread(
     orgId: string,
     chatId: string,
@@ -3161,6 +3229,17 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.REFS_BACKLINKS(orgId), undefined, params);
   }
 
+  /**
+   * Outbound prll:// refs authored in a set of sources, as raw ref_links rows
+   * (dedupe/group client-side). Pass `{ thread_root_id }` to list a whole
+   * thread's refs (root + all replies, resolved server-side — the client's
+   * reply window may be partial), or `{ source_type, source_ids }` for
+   * explicit sources (max 500; v1 accepts only message sources).
+   */
+  async listOutboundRefs(orgId: string, req: OutboundRefsRequest): Promise<OutboundRefsResponse> {
+    return this.request('POST', ENDPOINTS.REFS_OUTBOUND(orgId), req);
+  }
+
   /**
    * Bounded multi-hop walk of the prll:// reference graph around `uri`. `uri`
    * must be an entity-level prll:// URI — a refined URI (path/query/fragment) is
@@ -3567,6 +3646,75 @@ export class ParallClient {
     return this.request('GET', ENDPOINTS.ORG_EDGE_PROFILES(orgId, edgeId));
   }
 
+  /**
+   * Read a hosted Cloud Profile's egress-proxy status (manager-only: hosted
+   * human maintainer or org admin). Sanitized — the password never comes back.
+   * Typed errors: `EDGE_NOT_HOSTED` (BYOC device), `PROXY_CONFIG_CORRUPT` /
+   * validation codes as 422 when a stored config no longer passes current rules.
+   * `can_mutate` and `lease_status` are the authoritative idle gate; device
+   * list status is not a substitute.
+   */
+  async getEdgeProfileProxy(
+    orgId: string,
+    edgeId: string,
+    profileName: string,
+  ): Promise<EdgeProfileProxyStatus> {
+    return this.request('GET', ENDPOINTS.ORG_EDGE_PROFILE_PROXY(orgId, edgeId, profileName));
+  }
+
+  /**
+   * Set/replace the profile's egress proxy (full triple every time) — IDLE
+   * ONLY: while the profile's hosted browser is running (a viewer session is
+   * open or a pod is otherwise live) the server answers 409
+   * `EDGE_PROFILE_IN_USE`; close the viewer, wait for idle scale-to-zero, and
+   * retry. The next cold start uses the new egress; browser login state is
+   * preserved across it. Other typed errors: the validation vocabulary
+   * (`INVALID_PROXY_SERVER`, `PROXY_AUTH_INCOMPLETE`,
+   * `PROXY_SERVER_FORBIDDEN_TARGET`, …), `EDGE_DELETING` (409), and
+   * `SECRETBOX_UNCONFIGURED` (503 — server cannot store credentials safely),
+   * and `EDGE_PROFILE_PROXY_STALE` (409 — expectedVersion lost a tab race).
+   */
+  async setEdgeProfileProxy(
+    orgId: string,
+    edgeId: string,
+    profileName: string,
+    req: SetEdgeProfileProxyRequest,
+    expectedVersion?: string,
+  ): Promise<EdgeProfileProxyStatus> {
+    return this.request(
+      'PUT',
+      ENDPOINTS.ORG_EDGE_PROFILE_PROXY(orgId, edgeId, profileName),
+      req,
+      undefined,
+      false,
+      {
+        headers: expectedVersion ? { 'If-Match': `"proxy-${expectedVersion}"` } : undefined,
+      },
+    );
+  }
+
+  /**
+   * Clear the profile's egress proxy; the next pod start egresses directly.
+   * Idle-only like set — 409 `EDGE_PROFILE_IN_USE` while the browser is live.
+   */
+  async clearEdgeProfileProxy(
+    orgId: string,
+    edgeId: string,
+    profileName: string,
+    expectedVersion?: string,
+  ): Promise<EdgeProfileProxyStatus> {
+    return this.request(
+      'DELETE',
+      ENDPOINTS.ORG_EDGE_PROFILE_PROXY(orgId, edgeId, profileName),
+      undefined,
+      undefined,
+      false,
+      {
+        headers: expectedVersion ? { 'If-Match': `"proxy-${expectedVersion}"` } : undefined,
+      },
+    );
+  }
+
   /**
    * Execute a registry clip command on an Edge device.
    *
@@ -3664,6 +3812,8 @@ function normalizeWikiChangeset(changeset: WikiChangeset): WikiChangeset {
 
 export class ApiError extends Error {
   extras?: Record<string, unknown>;
+  /** Retry-After delta seconds when the server supplies one. */
+  retryAfterSeconds?: number;
   /** Attempted action (authorization denials) — e.g. "chat.add_member". */
   action?: string;
   /** Target resource URI that was evaluated — e.g. "prll://cht_…". */
@@ -3691,7 +3841,7 @@ export class ApiError extends Error {
  * See docs/engineering-design/error-contract-design.md
  */
 function buildApiError(
-  res: { status: number; statusText: string },
+  res: { status: number; statusText: string; headers?: { get(name: string): string | null } },
   rawErrorBody: unknown,
 ): ApiError {
   const errorBody =
@@ -3714,6 +3864,8 @@ function buildApiError(
     (typeof errorObj?.code === 'string' ? errorObj.code : undefined) ??
     (typeof errorBody.code === 'string' ? (errorBody.code as string) : undefined);
   const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
+  const retryAfter = Number(res.headers?.get('Retry-After'));
+  if (Number.isFinite(retryAfter) && retryAfter > 0) apiError.retryAfterSeconds = retryAfter;
   // Machine anchors: present under `error`, with a legacy flat fallback.
   const anchors = errorObj ?? errorBody;
   if (typeof anchors.action === 'string') apiError.action = anchors.action;

package/src/constants.ts

@@ -410,6 +410,9 @@ export const ENDPOINTS = {
   MESSAGE_WATCH: (id: string) => `${API_BASE}/messages/${id}/watch`,
   MESSAGE_WATCHERS: (id: string) => `${API_BASE}/messages/${id}/watchers`,
   MESSAGE_WATCHING: (id: string) => `${API_BASE}/messages/${id}/watching`,
+  MESSAGE_REACTIONS: (id: string) => `${API_BASE}/messages/${id}/reactions`,
+  MESSAGE_REACTION: (id: string, emoji: string) =>
+    `${API_BASE}/messages/${id}/reactions/${encodeURIComponent(emoji)}`,
 
   // Upload (org-scoped)
   UPLOAD_PRESIGN: (orgId: string) => `${API_BASE}/orgs/${orgId}/upload/presign`,
@@ -780,6 +783,8 @@ export const ENDPOINTS = {
   UNREAD: `${API_BASE}/me/unread`,
   ORG_UNREAD: (orgId: string) => `${API_BASE}/orgs/${orgId}/unread`,
   CHAT_READ: (orgId: string, chatId: string) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/read`,
+  CHAT_READ_ALL: (orgId: string, chatId: string) =>
+    `${API_BASE}/orgs/${orgId}/chats/${chatId}/read-all`,
   THREAD_UNREAD: (orgId: string, chatId: string, threadRootId: string) =>
     `${API_BASE}/orgs/${orgId}/chats/${chatId}/threads/${threadRootId}/unread`,
   THREAD_READ: (orgId: string, chatId: string, threadRootId: string) =>
@@ -788,6 +793,7 @@ export const ENDPOINTS = {
   // References (org-scoped)
   REFS_RESOLVE: (orgId: string) => `${API_BASE}/orgs/${orgId}/refs/resolve`,
   REFS_BACKLINKS: (orgId: string) => `${API_BASE}/orgs/${orgId}/refs/backlinks`,
+  REFS_OUTBOUND: (orgId: string) => `${API_BASE}/orgs/${orgId}/refs/outbound`,
   REFS_GRAPH: (orgId: string) => `${API_BASE}/orgs/${orgId}/refs/graph`,
   REFS_CHECK: (orgId: string) => `${API_BASE}/orgs/${orgId}/refs/check`,
 
@@ -876,7 +882,15 @@ export const ENDPOINTS = {
   ORG_EDGE_ONBOARDING: (orgId: string) => `/api/v1/orgs/${orgId}/edge/onboarding`,
   ORG_EDGE_PROFILES: (orgId: string, edgeId: string) =>
     `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles`,
+  // Per-profile egress proxy (hosted Cloud Profiles; manager-only, human-only).
+  ORG_EDGE_PROFILE_PROXY: (orgId: string, edgeId: string, profileName: string) =>
+    `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles/${encodeURIComponent(profileName)}/proxy`,
   ORG_EDGE_EXEC: (orgId: string) => `/api/v1/orgs/${orgId}/edge/exec`,
+  // Cloud Edge live viewer command (V1b) — api-server, gated on cap:edge-viewer.
+  // Same request/reply shape as the v2 browser-profile viewer, on the v3 edge
+  // pipe. Additive: does NOT replace BROWSER_PROFILE_VIEWER_COMMAND.
+  ORG_EDGE_VIEWER_COMMAND: (orgId: string, edgeId: string) =>
+    `/api/v1/orgs/${orgId}/edge/${edgeId}/viewer/command`,
   CLIP_CONNECTIONS: (orgId: string, clipId: string) =>
     `/api/v1/orgs/${orgId}/clip-registry/${clipId}/connections`,
   CLIP_CONNECTION: (orgId: string, connId: string) =>
@@ -941,6 +955,7 @@ export const WS_EVENTS = {
   MESSAGE_PATCH: 'message.patch',
   MESSAGE_EDIT: 'message.edit',
   MESSAGE_DELETE: 'message.delete',
+  MESSAGE_REACTION_UPDATED: 'message.reaction.updated',
   TYPING_UPDATE: 'typing.update',
   CHAT_UPDATE: 'chat.update',
   CHAT_DELETED: 'chat.deleted',
@@ -981,6 +996,7 @@ export const WS_EVENTS = {
   INBOX_UPDATE: 'inbox.update',
   INBOX_BULK_UPDATE: 'inbox.bulk_update',
   READ_POSITION_UPDATED: 'read_position.updated',
+  THREAD_READ_POSITION_UPDATED: 'thread_read_position.updated',
   DISPATCH_NEW: 'dispatch.new',
   DISPATCH_RECEIVED: 'dispatch.received',
   DISPATCH_RESOLVED: 'dispatch.resolved',

package/src/types.ts

@@ -111,6 +111,12 @@ export interface TransferChatOwnershipRequest {
 export interface UnreadEntry {
   count: number;
   mentions: number;
+  /** Share of `count` contributed by unread thread replies (only present when
+   *  the unread fetch opted into `include_thread_replies`). Top-level timeline
+   *  unread = count - (thread_count ?? 0). */
+  thread_count?: number;
+  /** Share of `mentions` contributed by unread thread replies. */
+  thread_mentions?: number;
   since?: string;
 }
 
@@ -273,6 +279,12 @@ export interface Message {
    * absent from the stack. A reload re-derives it from the server's view.
    */
   recent_repliers?: User[];
+  /**
+   * Per-viewer count of thread replies newer than the viewer's thread read
+   * cursor, excluding the viewer's own replies (root only). Populated on
+   * top-level list responses; omitted when zero.
+   */
+  unread_reply_count?: number;
   edited_at: string | null;
   deleted_at: string | null;
   created_at: string;
@@ -281,6 +293,27 @@ export interface Message {
   agent_session_id?: string | null;
   hints?: MessageHints | null;
   attachments?: Attachment[];
+  reactions?: ReactionSummary[];
+}
+
+/**
+ * Aggregated reactions for one emoji on a message.
+ *
+ * `has_reacted` is viewer-relative in REST responses. In
+ * `message.reaction.updated` WS broadcasts it is computed for the ACTOR who
+ * triggered the toggle — subscribers must recompute their own state from
+ * `user_ids` (see docs/engineering-design/ws-protocol.md).
+ */
+export interface ReactionSummary {
+  emoji: string;
+  count: number;
+  user_ids: string[];
+  has_reacted: boolean;
+}
+
+export interface ToggleReactionResponse {
+  added: boolean;
+  reactions: ReactionSummary[];
 }
 
 export interface Attachment {
@@ -1159,6 +1192,13 @@ export interface Task {
   seq_number: number | null;
   identifier: string | null;
   sort_order: number;
+  /**
+   * Planned start date, YYYY-MM-DD (calendar date, timezone-free) — the
+   * planned schedule's left edge, independent of started_at (when work
+   * actually began). Absent on servers older than migration 145. When both
+   * dates are set, planned_start_date <= due_date.
+   */
+  planned_start_date?: string | null;
   /** Planned completion date, YYYY-MM-DD (calendar date, timezone-free). */
   due_date: string | null;
   assignee?: User;
@@ -1246,6 +1286,8 @@ export interface CreateTaskRequest {
   project_id?: string;
   source_chat_id?: string;
   sort_order?: number;
+  /** Planned start date, YYYY-MM-DD. Must be <= due_date when both are set. */
+  planned_start_date?: string;
   /** Planned completion date, YYYY-MM-DD. */
   due_date?: string;
 }
@@ -1266,6 +1308,12 @@ export interface UpdateTaskRequest {
    * full column. Mutually exclusive with sort_order.
    */
   placement?: 'end';
+  /**
+   * Planned start date, YYYY-MM-DD; explicit null clears it. The post-patch
+   * state must satisfy planned_start_date <= due_date when both are set
+   * (400 INVALID_DATE_RANGE otherwise).
+   */
+  planned_start_date?: string | null;
   /** Planned completion date, YYYY-MM-DD; explicit null clears it. */
   due_date?: string | null;
   /**
@@ -2179,6 +2227,20 @@ export interface MessageDeleteData {
   thread_root_id?: string;
 }
 
+/**
+ * Payload of the `message.reaction.updated` WS broadcast. `reactions` is the
+ * full aggregated snapshot for the message; its `has_reacted` flags are
+ * actor-relative (see {@link ReactionSummary}) — recompute from `user_ids`.
+ */
+export interface ReactionUpdatedData {
+  message_id: string;
+  chat_id: string;
+  emoji: string;
+  user_id: string;
+  added: boolean;
+  reactions: ReactionSummary[];
+}
+
 export interface TypingUpdateData {
   chat_id: string;
   thread_root_id: string | null;
@@ -3073,6 +3135,13 @@ export interface ReadPositionUpdateData {
   last_read_message_id: string;
 }
 
+/** Per-thread read cursor sync across the user's devices. */
+export interface ThreadReadPositionUpdateData {
+  chat_id: string;
+  thread_root_id: string;
+  last_read_reply_id: string;
+}
+
 export interface NotificationAlertData {
   title: string;
   body: string;
@@ -3087,6 +3156,7 @@ export type WsEventMap = {
   'message.patch': MessagePatchData;
   'message.edit': MessageEditData;
   'message.delete': MessageDeleteData;
+  'message.reaction.updated': ReactionUpdatedData;
   'typing.update': TypingUpdateData;
   'chat.created': ChatCreatedData;
   'chat.update': ChatUpdateData;
@@ -3131,6 +3201,7 @@ export type WsEventMap = {
   'inbox.update': InboxUpdateData;
   'inbox.bulk_update': InboxBulkUpdateData;
   'read_position.updated': ReadPositionUpdateData;
+  'thread_read_position.updated': ThreadReadPositionUpdateData;
   'dispatch.new': DispatchNewData;
   'dispatch.received': DispatchReceivedData;
   'dispatch.resolved': DispatchResolvedData;
@@ -3335,6 +3406,37 @@ export interface BacklinksResponse {
   next_cursor?: string;
 }
 
+/**
+ * Request for POST /orgs/{orgId}/refs/outbound — two mutually exclusive
+ * forms, modeled as a union so an invalid mixed shape fails at compile time:
+ * `thread_root_id` resolves a thread's message set server-side (root + ALL
+ * non-deleted replies — the client's reply window may be partial), while
+ * `source_type` + `source_ids` lists explicit sources (max 500; v1 accepts
+ * only `message` sources).
+ */
+export type OutboundRefsRequest =
+  | { thread_root_id: string; source_type?: never; source_ids?: never }
+  | { source_type: string; source_ids: string[]; thread_root_id?: never };
+
+/** One raw ref_links row; dedupe/grouping is a client concern. */
+export interface OutboundRefItem {
+  uri: string;
+  target_type: string;
+  target_id: string;
+  target_path?: string;
+  target_frag?: string;
+  context?: string;
+  source_type: string;
+  source_id: string;
+  position: number;
+}
+
+export interface OutboundRefsResponse {
+  data: OutboundRefItem[];
+  /** Set when the server-side sanity cap dropped the tail of the row set. */
+  truncated?: boolean;
+}
+
 /**
  * One entity in a multi-hop ref-graph traversal (GET /refs/graph). `id`/`uri` are
  * the ref_links endpoint identifier: a bare prll:// entity id for most nodes
@@ -3976,6 +4078,29 @@ export interface BrowserViewerCommandResponse {
   result: Record<string, unknown> | null;
 }
 
+/**
+ * Cloud Edge live viewer (V1b, design §6). Same request/reply shape as the v2
+ * browser-profile viewer — the transport-agnostic `BrowserViewer` client drives
+ * either — but a distinct type so the edge viewer surface never depends on the
+ * v2 browser-profile viewer symbols.
+ */
+export interface EdgeViewerCommandRequest {
+  /** Correlates a viewer session. Omit on `stream.start`; the server returns one. */
+  session_id?: string;
+  command: string;
+  input?: Record<string, unknown>;
+}
+
+export interface EdgeViewerCommandResponse {
+  session_id: string;
+  /**
+   * Command-specific result. For `stream.start`:
+   * `{ offer_sdp, candidates, ice_servers, streamed_tab_id }`. May be `null` on
+   * the wire (a nil Go result map serializes as JSON null); coalesce to `{}`.
+   */
+  result: Record<string, unknown> | null;
+}
+
 export interface GrantBrowserProfileConsentRequest {
   clip_id: string;
 }
@@ -4187,6 +4312,45 @@ export interface EdgeBrowserProfile {
   is_default: boolean;
   created_at: string;
   updated_at: string;
+  /**
+   * True when the profile has a fixed egress proxy configured (hosted Cloud
+   * Profiles). Presence flag only — endpoint/username/password are readable
+   * exclusively by managers via the dedicated proxy endpoint, and the password
+   * never leaves the server.
+   */
+  proxy_configured?: boolean;
+}
+
+/**
+ * Sanitized per-profile egress proxy status (hosted Cloud Profiles) — the GET
+ * response and the PUT/DELETE result. NEVER carries the password; `password_set`
+ * is the only trace of it.
+ */
+export interface EdgeProfileProxyStatus {
+  configured: boolean;
+  server?: string;
+  username?: string;
+  password_set: boolean;
+  /** Opaque compare-and-swap token for conditional PUT/DELETE. */
+  version: string;
+  /** Authoritative mutation gate; false whenever a non-released lease exists. */
+  can_mutate: boolean;
+  /** Actual lease state blocking a mutation (never inferred from device status). */
+  lease_status?: 'pending' | 'assigned' | 'active' | 'releasing' | 'repair';
+  /** Suggested delay before re-reading authoritative state. */
+  retry_after_seconds?: number;
+}
+
+/**
+ * PUT body for a profile's egress proxy: the FULL triple every time (no
+ * tri-state merge — the stored blob is encrypted, so replace always re-supplies
+ * complete credentials). Clearing is DELETE, never an empty PUT. Username and
+ * password go together or not at all.
+ */
+export interface SetEdgeProfileProxyRequest {
+  server: string;
+  username?: string;
+  password?: string;
 }
 
 export interface ClipConnection {