@gravity-rail/sdk 0.21.0 → 0.32.0

package/dist/{chunk-24L4RD4Z.js → chunk-N446FGCT.js}

@@ -1,7 +1,7 @@
 import {
   ApiError,
   BaseApiClient
-} from "./chunk-7OLBLLV7.js";
+} from "./chunk-P2E6LU7I.js";
 
 // src/api/abilities.ts
 var AbilitiesApi = class extends BaseApiClient {
@@ -1238,17 +1238,6 @@ var CallsApi = class extends BaseApiClient {
       `w/${wid}/calls${params.toString() ? `?${params.toString()}` : ""}`
     );
   }
-  /** Initiate a new outbound call. */
-  async initiateCall(wid, request) {
-    return this.fetch(`w/${wid}/call`, {
-      method: "POST",
-      body: JSON.stringify(request)
-    });
-  }
-  /** Get a voice authentication token for real-time audio. */
-  async getVoiceToken(wid) {
-    return this.fetch(`w/${wid}/voice/token`);
-  }
   /** Get message timing data for a chat recording. */
   async getMessageTiming(wid, chatId) {
     return this.fetch(`w/${wid}/recordings/chat/${chatId}/message-timing`);
@@ -1374,6 +1363,26 @@ var ChatsApi = class extends BaseApiClient {
   async getChat(wid, id) {
     return this.fetch(`w/${wid}/chats/${id}`);
   }
+  /**
+   * Get a short-lived, interactive AgentCore browser view for this Chat.
+   *
+   * The signed URL is deliberately response-local. Callers must keep it in
+   * memory only and request a fresh value when reopening the view.
+   */
+  async getChatBrowserLiveView(wid, chatId) {
+    const response = await this.fetchRaw(`w/${wid}/chats/${chatId}/browser/live-view`);
+    if (response.status === 204) return null;
+    return response.json();
+  }
+  /**
+   * Which machine resources this Chat is running right now.
+   *
+   * Infrastructure state only — no Chat content — so it is safe to poll while
+   * a Chat is open.
+   */
+  async getChatMachineResources(wid, chatId) {
+    return this.fetch(`w/${wid}/chats/${chatId}/machine-resources`);
+  }
   /**
    * Create-chat preflight for SMS: is a conversation already live between this
    * workspace number and this member?
@@ -1401,6 +1410,23 @@ var ChatsApi = class extends BaseApiClient {
   async getChatCallbacks(wid, chatId) {
     return this.fetch(`w/${wid}/chats/${chatId}/callbacks`);
   }
+  /**
+   * List EHR write-back outcomes for a chat (newest first).
+   *
+   * Operator surface: the endpoint requires `chats:read` in addition to the
+   * chat's own object authorization, so a chat owner reading their own chat
+   * does not reach it. The response carries IDs and closed-vocabulary codes
+   * only — no note body, summary, member fields, or provider messages.
+   */
+  async getChatEhrWritebackOutcomes(wid, chatId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.append("limit", options.limit.toString());
+    if (options.cursor) params.append("cursor", options.cursor);
+    const queryString = params.toString();
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/ehr-writeback-outcomes${queryString ? `?${queryString}` : ""}`
+    );
+  }
   /** Cancel a pending scheduled callback on a chat. */
   async cancelChatCallback(wid, chatId, callbackId) {
     return this.fetch(
@@ -1412,6 +1438,18 @@ var ChatsApi = class extends BaseApiClient {
   async getChatTodos(wid, chatId) {
     return this.fetch(`w/${wid}/chats/${chatId}/todos`);
   }
+  /**
+   * The caller's own live inline-connect link for a chat.
+   *
+   * An `inline_connect` prompt (`UiPromptPresented.connect`) names the
+   * connection but carries no URL; fetch it here when the member chooses to
+   * connect. 404 when nothing is live for the caller in this chat.
+   */
+  async getInlineConnectLink(wid, chatId, appSlug) {
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/inline-connect/${encodeURIComponent(appSlug)}/link`
+    );
+  }
   /** Get loaded and revealed skills for a chat. */
   async getChatSkills(wid, chatId) {
     return this.fetch(`w/${wid}/chats/${chatId}/skills`);
@@ -1446,6 +1484,23 @@ var ChatsApi = class extends BaseApiClient {
       method: "PUT"
     });
   }
+  /** Start an interaction within an existing Chat without changing its channel. */
+  async createChatInteractionSession(wid, chatId, request) {
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/interaction-sessions`,
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    );
+  }
+  /** End one mode session and append its replacement in the same Chat. */
+  async transitionChatInteractionSession(wid, chatId, sessionId, request) {
+    return this.fetch(
+      `w/${wid}/chats/${chatId}/interaction-sessions/${encodeURIComponent(sessionId)}/transition`,
+      { method: "POST", body: JSON.stringify(request) }
+    );
+  }
   /** Create a new chat. */
   async createChat(wid, chat) {
     const { agentMemberId, ...rest } = chat;
@@ -1536,10 +1591,11 @@ var ChatsApi = class extends BaseApiClient {
   }
   /** List messages in a chat with optional pagination.
    *  ``id`` is the numeric chat id (documented) or the chat uuid (accepted). */
-  async getChatMessages(wid, id, limit, offset) {
+  async getChatMessages(wid, id, limit, offset, before) {
     const params = new URLSearchParams();
     if (limit) params.append("limit", limit.toString());
     if (offset) params.append("offset", offset.toString());
+    if (before) params.append("before", before);
     return this.fetch(
       `w/${wid}/chats/${id}/messages${params.toString() ? `?${params.toString()}` : ""}`
     );
@@ -1888,6 +1944,35 @@ var CustomToolkitsApi = class extends BaseApiClient {
 
 // src/api/data-types.ts
 var DataTypesApi = class extends BaseApiClient {
+  /** Read the local Form's draft and optimistic publication counters. */
+  async getDataTypeDraft(wid, id) {
+    return this.fetch(`w/${wid}/data-types/${id}/schema-draft`);
+  }
+  /** Save a draft without changing the schema used to validate live records. */
+  async saveDataTypeDraft(wid, id, request) {
+    return this.fetch(`w/${wid}/data-types/${id}/schema-draft`, {
+      method: "PUT",
+      body: JSON.stringify(request)
+    });
+  }
+  /** Publish the expected draft as the next immutable local schema version. */
+  async publishDataTypeDraft(wid, id, request) {
+    return this.fetch(`w/${wid}/data-types/${id}/schema-publish`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** List schema history newest first; use the last version as the next cursor. */
+  async getDataTypeVersions(wid, id, options) {
+    const params = new URLSearchParams();
+    if (options?.beforeVersion !== void 0)
+      params.set("beforeVersion", String(options.beforeVersion));
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.fetch(
+      `w/${wid}/data-types/${id}/schema-versions${query ? `?${query}` : ""}`
+    );
+  }
   /** List all data types for a workspace, optionally filtering by archived status. */
   async getDataTypes(wid, options) {
     const params = new URLSearchParams();
@@ -1956,7 +2041,6 @@ var DataTypesApi = class extends BaseApiClient {
     const params = new URLSearchParams();
     if (options?.memberId !== void 0) params.append("member_id", options.memberId.toString());
     if (options?.memberIds?.length) params.append("member_ids", options.memberIds.join(","));
-    if (options?.recordId !== void 0) params.append("record_id", options.recordId.toString());
     if (options?.search) params.append("search", options.search);
     if (options?.searchField) params.append("search_field", options.searchField);
     if (options?.dataRecordFilterId != null) {
@@ -2470,6 +2554,22 @@ var EventsApi = class extends BaseApiClient {
       }
     );
   }
+  /**
+   * Preview what would stop a draft Routine placing its scheduled outbound
+   * calls — the Member voice opt-out, a missing member phone, or a
+   * workspace number that is stale, archived, or not voice-enabled.
+   * Non-persisting and advisory. The audience is reported as counts only,
+   * never as Member rows.
+   */
+  async previewRoutineVoiceReadiness(wid, request) {
+    return this.fetch(
+      `w/${wid}/routines/preview-voice-readiness`,
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    );
+  }
   /** List routines with optional pagination and active status filtering. */
   async getRoutines(wid, options = {}) {
     const params = new URLSearchParams();
@@ -2479,6 +2579,8 @@ var EventsApi = class extends BaseApiClient {
     if (options.sortOrder) params.append("sortOrder", options.sortOrder);
     if (options.owner) params.append("owner", options.owner);
     if (options.ownerId) params.append("ownerId", options.ownerId.toString());
+    if (options.agentId) params.append("agentId", options.agentId.toString());
+    if (options.agentOnly) params.append("agentOnly", "true");
     return this.fetch(
       `w/${wid}/routines${params.toString() ? `?${params.toString()}` : ""}`
     );
@@ -3343,7 +3445,14 @@ var InboxesApi = class extends BaseApiClient {
   async getInboxes(wid) {
     return this.fetch(`w/${wid}/inboxes`);
   }
-  /** Get an inbox by ID. */
+  /**
+   * Get an inbox by ID or UUID.
+   *
+   * The route has always taken either (`inbox_id: str = Path(..., description=
+   * "Inbox ID or UUID")`); the signature said `number`, which put the UUID path
+   * out of reach for a caller holding an inbox ref from the activity feed —
+   * where refs are UUID-only by design.
+   */
   async getInbox(wid, id) {
     return this.fetch(`w/${wid}/inboxes/${id}`);
   }
@@ -3395,10 +3504,18 @@ var InboxesApi = class extends BaseApiClient {
     });
   }
   /** Reply to an email from the inbox. */
-  async replyToEmail(wid, inboxId, emailId, content) {
+  async replyToEmail(wid, inboxId, emailId, content, htmlContent) {
+    const body = { content, htmlContent };
     return this.fetch(`w/${wid}/inboxes/${inboxId}/emails/${emailId}/reply`, {
       method: "POST",
-      body: JSON.stringify({ content })
+      body: JSON.stringify(body)
+    });
+  }
+  /** Compose and send a new email from an inbox. */
+  async sendInboxEmail(wid, inboxId, body) {
+    return this.fetch(`w/${wid}/inboxes/${inboxId}/emails`, {
+      method: "POST",
+      body: JSON.stringify(body)
     });
   }
   /**
@@ -4053,17 +4170,11 @@ var MembersApi = class extends BaseApiClient {
    * operator can decide whether to skip or explicitly overwrite before
    * committing. Requires MEMBERS_ADMIN and is bulk-PHI audited server-side.
    */
-  async previewImportMembers(wid, file, newMemberRoleId, options) {
+  async previewImportMembers(wid, file, newMemberRoleId) {
     const formData = new FormData();
     formData.append("file", file);
     const params = new URLSearchParams();
     params.append("new_member_role_id", newMemberRoleId.toString());
-    if (options?.trustEmailAddresses) {
-      params.append("trust_email_addresses", "true");
-    }
-    if (options?.trustPhoneNumbers) {
-      params.append("trust_phone_numbers", "true");
-    }
     const response = await this.fetchRaw(
       `w/${wid}/members/import/preview?${params.toString()}`,
       {
@@ -4090,12 +4201,6 @@ var MembersApi = class extends BaseApiClient {
     formData.append("file", file);
     const params = new URLSearchParams();
     params.append("new_member_role_id", newMemberRoleId.toString());
-    if (options?.trustEmailAddresses) {
-      params.append("trust_email_addresses", "true");
-    }
-    if (options?.trustPhoneNumbers) {
-      params.append("trust_phone_numbers", "true");
-    }
     if (options?.identityConflictPolicy) {
       params.append("identity_conflict_policy", options.identityConflictPolicy);
     }
@@ -4344,6 +4449,28 @@ var MembersApi = class extends BaseApiClient {
   async getMemberSyncLinks(wid, memberId) {
     return this.fetch(`w/${wid}/members/${memberId}/sync-links`);
   }
+  async getMemberRelationships(wid, memberId, params) {
+    const search = new URLSearchParams();
+    if (params?.page) search.set("page", String(params.page));
+    if (params?.pageSize) search.set("pageSize", String(params.pageSize));
+    if (params?.kind) search.set("kind", params.kind);
+    const qs = search.toString();
+    return this.fetch(
+      `w/${wid}/members/${memberId}/relationships${qs ? `?${qs}` : ""}`
+    );
+  }
+  async createMemberRelationship(wid, memberId, body) {
+    return this.fetch(`w/${wid}/members/${memberId}/relationships`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async archiveMemberRelationship(wid, memberId, relationshipId) {
+    return this.fetch(
+      `w/${wid}/members/${memberId}/relationships/${relationshipId}`,
+      { method: "DELETE" }
+    );
+  }
 };
 
 // src/api/monday.ts
@@ -4591,12 +4718,6 @@ var OperatorApi = class extends BaseApiClient {
   async getPresenceStatus(wid) {
     return this.fetch(`w/${wid}/presence/me`);
   }
-  /** Disconnect the current member's presence session. */
-  async disconnectPresence(wid) {
-    return this.fetch(`w/${wid}/presence/disconnect-self`, {
-      method: "POST"
-    });
-  }
   // Operator chat message methods
   /** Get paginated chat messages for an operator chat. */
   async getOperatorChatMessages(wid, chatId, limit = 50, offset = 0) {
@@ -5166,6 +5287,28 @@ var OrgApi = class extends BaseApiClient {
   async getLegalEntity(orgUuid, legalEntityUuid) {
     return this.fetch(`o/${orgUuid}/legal-entities/${legalEntityUuid}`);
   }
+  /**
+   * Read one registration draft for a legal entity.
+   *
+   * A draft is what the operator has typed but not submitted. It exists so
+   * data entry is never gated on a prerequisite: someone can write down the
+   * caller-ID name today and submit it the day the business is verified.
+   */
+  async getRegistrationDraft(orgUuid, legalEntityUuid, kind) {
+    return this.fetch(
+      `o/${orgUuid}/legal-entities/${legalEntityUuid}/registration-drafts/${kind}`
+    );
+  }
+  /**
+   * Save one registration draft. Always accepted — the server refuses only
+   * an oversized body, never an unfinished one.
+   */
+  async saveRegistrationDraft(orgUuid, legalEntityUuid, kind, data) {
+    return this.fetch(
+      `o/${orgUuid}/legal-entities/${legalEntityUuid}/registration-drafts/${kind}`,
+      { method: "PUT", body: JSON.stringify({ data }) }
+    );
+  }
   /** Cached voice trust product state (CNAM / SHAKEN-STIR / Voice Integrity) for one legal entity. */
   async getVoiceTrustProducts(orgUuid, legalEntityUuid) {
     return this.fetch(
@@ -5339,6 +5482,42 @@ var OrgApi = class extends BaseApiClient {
       }
     );
   }
+  // =========================================================================
+  // Organization webhook endpoints (GRA-8314)
+  // =========================================================================
+  async listOrgWebhookEndpoints(orgIdOrUuid) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks`);
+  }
+  /**
+   * The subscribable event-type vocabulary for the org UI's event-type
+   * picker — exactly what the create/update validators accept, so the UI
+   * never offers a type the API would reject.
+   */
+  async listOrgWebhookEventTypes(orgIdOrUuid) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks/event-types`);
+  }
+  async createOrgWebhookEndpoint(orgIdOrUuid, data) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateOrgWebhookEndpoint(orgIdOrUuid, endpointUuid, data) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks/${endpointUuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteOrgWebhookEndpoint(orgIdOrUuid, endpointUuid) {
+    return this.fetch(`o/${orgIdOrUuid}/webhooks/${endpointUuid}`, {
+      method: "DELETE"
+    });
+  }
+  async listOrgWebhookEndpointDeliveries(orgIdOrUuid, endpointUuid, limit = 50) {
+    return this.fetch(
+      `o/${orgIdOrUuid}/webhooks/${endpointUuid}/deliveries?limit=${limit}`
+    );
+  }
 };
 function businessProfilePath(orgUuid, legalEntityUuid) {
   return legalEntityUuid ? `o/${orgUuid}/legal-entities/${legalEntityUuid}/business-profile` : `o/${orgUuid}/business-profile`;
@@ -5759,6 +5938,8 @@ var PersonasApi = class extends BaseApiClient {
     const q = new URLSearchParams();
     if (params?.page !== void 0) q.set("page", String(params.page));
     if (params?.pageSize !== void 0) q.set("pageSize", String(params.pageSize));
+    if (params?.includeArchived !== void 0)
+      q.set("includeArchived", String(params.includeArchived));
     const qs = q.toString() ? `?${q.toString()}` : "";
     return this.fetch(`w/${wid}/personas${qs}`);
   }
@@ -5777,6 +5958,18 @@ var PersonasApi = class extends BaseApiClient {
       body: JSON.stringify(data)
     });
   }
+  async archivePersona(wid, id) {
+    return this.fetch(`w/${wid}/personas/${id}/archive`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  async unarchivePersona(wid, id) {
+    return this.fetch(`w/${wid}/personas/${id}/unarchive`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
   async deletePersona(wid, id) {
     return this.fetch(`w/${wid}/personas/${id}`, { method: "DELETE" });
   }
@@ -7268,6 +7461,59 @@ var JourneysApi = class extends BaseApiClient {
   async getJourneyAuthoring(wid, journeyId) {
     return this.fetch(`w/${wid}/journeys/${journeyId}/authoring`);
   }
+  /**
+   * Atomically replace a v2 Journey's whole definition (Journey v2 plan §3.8).
+   *
+   * ONE request carries the ordered touches, the wait into each touch, the
+   * ordered Endings, action associations, goals, and
+   * `expectedUpdatedAt` for optimistic concurrency. It is a full replacement,
+   * not a patch — omitting `goals` is the one exception and leaves them alone.
+   *
+   * Returns the AUTHORING projection (`Journey`): the caller just wrote the
+   * CEL and holds the `journeys:write` scope that authorizes reading it back.
+   *
+   * Refusals are HTTP 409 with a stable `code`:
+   *   * `journey_v2_execution_model_mismatch` — the Journey is legacy; use the
+   *     step/connection/goal endpoints.
+   *   * `journey_v2_structural_edit_not_allowed` — it is live; pause it first.
+   *   * `journey_v2_definition_conflict` — someone saved first; reload.
+   *   * `journey_v2_invalid_topology` — the resulting graph is not executable;
+   *     the body carries `issues` (codes and resource uuids, never CEL).
+   */
+  async putJourneyV2Definition(wid, journeyId, data) {
+    return this.fetch(`w/${wid}/journeys/${journeyId}/v2-definition`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Dry-run the v2 publish validator against the STORED definition.
+   *
+   * Answers "could I activate this right now?" without attempting the
+   * transition. Issues carry closed codes and resource uuids only — never CEL
+   * and never member data — so they are safe to render or log.
+   */
+  async getJourneyV2Validation(wid, journeyId) {
+    return this.fetch(
+      `w/${wid}/journeys/${journeyId}/v2-definition/validation`
+    );
+  }
+  /**
+   * MemberFilter ids and names, for the Journey authoring picker.
+   *
+   * A v2 wait, route or Ending may carry a structured MemberFilter predicate
+   * and the author selects it by NAME (rule-filters plan §3.10). This is the
+   * catalogue for that control and the whole of what it needs: two scalars per
+   * filter, no `query` predicate, no rules, no counts.
+   *
+   * Authorized on `journeys:write` alone — deliberately NOT the Members
+   * surface's `MembersApi.getMemberFilters`, which is `members:read`
+   * because it returns each filter's predicate. Journey authoring should not
+   * require Member-read access to name a cohort.
+   */
+  async getJourneyFilterOptions(wid) {
+    return this.fetch(`w/${wid}/journeys/filter-options`);
+  }
   /** Create a new journey. Returns the READ projection (`JourneyRead`). */
   async createJourney(wid, data) {
     return this.fetch(`w/${wid}/journeys`, {
@@ -7275,7 +7521,14 @@ var JourneysApi = class extends BaseApiClient {
       body: JSON.stringify(data)
     });
   }
-  /** Update an existing journey. Returns the READ projection (`JourneyRead`). */
+  /**
+   * Update an existing journey. Returns the READ projection (`JourneyRead`).
+   *
+   * `executionModel` is excluded: it is a CREATE-only field. Flipping a live
+   * Journey's engine is a guarded, audited migration operation (Journey v2
+   * plan §3.11), so the server has no update counterpart and sending one here
+   * would silently do nothing.
+   */
   async updateJourney(wid, journeyId, data) {
     return this.fetch(`w/${wid}/journeys/${journeyId}`, {
       method: "PUT",
@@ -7382,8 +7635,6 @@ var JourneysApi = class extends BaseApiClient {
       qs.set("currentTaskId", String(params.currentTaskId));
     if (params?.runtimeFailureEdgeId !== void 0)
       qs.set("runtimeFailureEdgeId", String(params.runtimeFailureEdgeId));
-    if (params?.memberJourneyId !== void 0)
-      qs.set("memberJourneyId", String(params.memberJourneyId));
     const query = qs.toString();
     return this.fetch(
       `w/${wid}/journeys/${journeyId}/members${query ? `?${query}` : ""}`
@@ -7537,6 +7788,15 @@ var WorkflowsApi = class extends BaseApiClient {
   async getWorkflow(wid, id) {
     return this.fetch(`w/${wid}/workflows/${id}`);
   }
+  async getWorkflowOpeningTurnConversionReport(wid, id) {
+    return this.fetch(`w/${wid}/workflows/${id}/opening-turn/conversion-report`);
+  }
+  async convertWorkflowStartTaskOpeningMessage(wid, id, expectedRuleId) {
+    return this.fetch(`w/${wid}/workflows/${id}/opening-turn/convert-start-task-message`, {
+      method: "POST",
+      body: JSON.stringify({ expectedRuleId })
+    });
+  }
   /** Get activity metrics for a single workflow. */
   async getWorkflowActivity(wid, id, options) {
     const params = options?.days ? `?days=${options.days}` : "";
@@ -8028,7 +8288,9 @@ var Scope = /* @__PURE__ */ ((Scope2) => {
 var BulkMemberResultStatus = {
   created: "created",
   updated: "updated",
-  failed: "failed"
+  failed: "failed",
+  conflict: "conflict",
+  skipped: "skipped"
 };
 var MemberImportMatchInfoMatchType = {
   external_id: "external_id",
@@ -8042,6 +8304,7 @@ var MemberImportPreviewRowAction = {
   update: "update",
   unchanged: "unchanged",
   conflict: "conflict",
+  skipped: "skipped",
   error: "error"
 };
 
@@ -8190,6 +8453,8 @@ var EventRuleActionType = /* @__PURE__ */ ((EventRuleActionType2) => {
   EventRuleActionType2["CONNECTOR_OPERATION"] = "connector:operation";
   EventRuleActionType2["ECW_REFRESH_MEMBER_ENCOUNTERS"] = "ecw:refresh_member_encounters";
   EventRuleActionType2["PLAY_AUDIO"] = "audio:play";
+  EventRuleActionType2["CHARLESTON_SEND_PMD_PAGE"] = "charleston:send_pmd_page";
+  EventRuleActionType2["PATIENTSYNC_TRANSFER"] = "patientsync:transfer";
   return EventRuleActionType2;
 })(EventRuleActionType || {});
 function eventRuleActionParams(params) {
@@ -8211,6 +8476,7 @@ var WorkspaceFeature = /* @__PURE__ */ ((WorkspaceFeature2) => {
   WorkspaceFeature2["BROWSER"] = "browser";
   WorkspaceFeature2["WEB_SEARCH"] = "web_search";
   WorkspaceFeature2["CALENDAR"] = "calendar";
+  WorkspaceFeature2["JOURNEY_V2_EDITOR"] = "journey_v2_editor";
   WorkspaceFeature2["EXPERIMENTS"] = "experiments";
   WorkspaceFeature2["MAILBOX_USER_INPUT"] = "mailbox_user_input";
   WorkspaceFeature2["FORKED_TRAJECTORIES"] = "forked_trajectories";
@@ -8336,6 +8602,7 @@ var ModelProvider = {
   elevenlabs: "elevenlabs",
   deepgram: "deepgram",
   xai: "xai",
+  fireworks: "fireworks",
   custom: "custom"
 };
 var ModelType = {
@@ -8389,6 +8656,24 @@ var FhirClientType = /* @__PURE__ */ ((FhirClientType2) => {
   return FhirClientType2;
 })(FhirClientType || {});
 
+// src/types/generated/qualification.ts
+var TestChatRunLane = {
+  text: "text",
+  web_realtime: "web_realtime",
+  core_agent_only: "core_agent_only",
+  unsupported: "unsupported",
+  unknown: "unknown"
+};
+var TestChatRunOutcome = {
+  simulator_end: "simulator_end",
+  terminal_tool: "terminal_tool",
+  agent_silent: "agent_silent",
+  max_turns: "max_turns",
+  human_end: "human_end",
+  configuration_failure: "configuration_failure",
+  instrument_failure: "instrument_failure"
+};
+
 // src/types/qualification-types.ts
 var CriterionType = /* @__PURE__ */ ((CriterionType2) => {
   CriterionType2["EXPRESSION"] = "expression";
@@ -8447,10 +8732,242 @@ var ConsentMethod = /* @__PURE__ */ ((ConsentMethod2) => {
   return ConsentMethod2;
 })(ConsentMethod || {});
 
+// src/types/generated/member_relationship.ts
+var MemberRelationshipKind = {
+  parent_of: "parent_of",
+  sibling_of: "sibling_of",
+  spouse_of: "spouse_of",
+  caregiver_of: "caregiver_of",
+  emergency_contact_of: "emergency_contact_of",
+  next_of_kin_of: "next_of_kin_of",
+  legal_guardian_of: "legal_guardian_of",
+  healthcare_agent_of: "healthcare_agent_of",
+  doctor_of: "doctor_of",
+  primary_contact_of: "primary_contact_of"
+};
+var RelatedMemberRole = {
+  parent: "parent",
+  child: "child",
+  sibling: "sibling",
+  spouse: "spouse",
+  caregiver: "caregiver",
+  care_recipient: "care_recipient",
+  emergency_contact: "emergency_contact",
+  emergency_contact_for: "emergency_contact_for",
+  next_of_kin: "next_of_kin",
+  next_of_kin_for: "next_of_kin_for",
+  legal_guardian: "legal_guardian",
+  legal_guardian_for: "legal_guardian_for",
+  healthcare_agent: "healthcare_agent",
+  healthcare_agent_for: "healthcare_agent_for",
+  doctor: "doctor",
+  patient: "patient",
+  primary_contact: "primary_contact",
+  primary_contact_for: "primary_contact_for"
+};
+var RelationshipCardinality = {
+  many_to_many: "many_to_many",
+  one_to_one: "one_to_one",
+  one_per_target: "one_per_target"
+};
+
+// src/types/generated/member_relationship_catalog.ts
+var MEMBER_RELATIONSHIP_KINDS = [
+  {
+    "kind": "parent_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "parent",
+        "label": "Parent",
+        "inverseLabel": "Child",
+        "description": "This person is a parent of the member. For a minor, also add Legal guardian if they should read the chart."
+      },
+      {
+        "role": "child",
+        "label": "Child",
+        "inverseLabel": "Parent",
+        "description": "This person is a child of the member."
+      }
+    ]
+  },
+  {
+    "kind": "sibling_of",
+    "cardinality": "many_to_many",
+    "symmetric": true,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "sibling",
+        "label": "Sibling",
+        "inverseLabel": "Sibling",
+        "description": "These members are siblings."
+      }
+    ]
+  },
+  {
+    "kind": "spouse_of",
+    "cardinality": "one_to_one",
+    "symmetric": true,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "spouse",
+        "label": "Spouse",
+        "inverseLabel": "Spouse",
+        "description": "These members are spouses or partners."
+      }
+    ]
+  },
+  {
+    "kind": "caregiver_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "caregiver",
+        "label": "Caregiver",
+        "inverseLabel": "Care recipient",
+        "description": "This person provides care for the member at home."
+      },
+      {
+        "role": "care_recipient",
+        "label": "Care recipient",
+        "inverseLabel": "Caregiver",
+        "description": "This person receives care from the member."
+      }
+    ]
+  },
+  {
+    "kind": "emergency_contact_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "emergency_contact",
+        "label": "Emergency contact",
+        "inverseLabel": "Emergency contact for",
+        "description": "This person is the member's emergency contact."
+      },
+      {
+        "role": "emergency_contact_for",
+        "label": "Emergency contact for",
+        "inverseLabel": "Emergency contact",
+        "description": "The member is listed as this person's emergency contact."
+      }
+    ]
+  },
+  {
+    "kind": "next_of_kin_of",
+    "cardinality": "one_per_target",
+    "symmetric": false,
+    "grantsChartAccess": false,
+    "roles": [
+      {
+        "role": "next_of_kin",
+        "label": "Next of kin",
+        "inverseLabel": "Next of kin for",
+        "description": "This person is the member's designated next of kin. A member has at most one."
+      },
+      {
+        "role": "next_of_kin_for",
+        "label": "Next of kin for",
+        "inverseLabel": "Next of kin",
+        "description": "The member is this person's designated next of kin."
+      }
+    ]
+  },
+  {
+    "kind": "legal_guardian_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "legal_guardian",
+        "label": "Legal guardian",
+        "inverseLabel": "Legal guardian for",
+        "description": "Court-appointed guardian, or parent/person with parental responsibility for a minor."
+      },
+      {
+        "role": "legal_guardian_for",
+        "label": "Legal guardian for",
+        "inverseLabel": "Legal guardian",
+        "description": "The member is this person's legal guardian."
+      }
+    ]
+  },
+  {
+    "kind": "healthcare_agent_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "healthcare_agent",
+        "label": "Healthcare agent",
+        "inverseLabel": "Healthcare agent for",
+        "description": "Healthcare power of attorney or health proxy."
+      },
+      {
+        "role": "healthcare_agent_for",
+        "label": "Healthcare agent for",
+        "inverseLabel": "Healthcare agent",
+        "description": "The member is this person's healthcare agent (healthcare power of attorney or health proxy)."
+      }
+    ]
+  },
+  {
+    "kind": "doctor_of",
+    "cardinality": "many_to_many",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "doctor",
+        "label": "Doctor",
+        "inverseLabel": "Patient",
+        "description": "This person is a treating clinician for the member."
+      },
+      {
+        "role": "patient",
+        "label": "Patient",
+        "inverseLabel": "Doctor",
+        "description": "This person is a patient of the member."
+      }
+    ]
+  },
+  {
+    "kind": "primary_contact_of",
+    "cardinality": "one_per_target",
+    "symmetric": false,
+    "grantsChartAccess": true,
+    "roles": [
+      {
+        "role": "primary_contact",
+        "label": "Primary contact",
+        "inverseLabel": "Primary contact for",
+        "description": "This person is the organization's primary contact for the member. A member has at most one."
+      },
+      {
+        "role": "primary_contact_for",
+        "label": "Primary contact for",
+        "inverseLabel": "Primary contact",
+        "description": "The member is this person's assigned primary contact inside the organization."
+      }
+    ]
+  }
+];
+
 // src/types/config-health-types.ts
 var CONFIG_HEALTH_FACADE_CHECK_SLUGS = [
   "workflow.config",
   "journey.authoring",
+  "journey.v2_validation",
   "workflow.access",
   "routine.workflow_access",
   "workspace.validation"
@@ -8459,85 +8976,20 @@ function isConfigHealthFacadeCheckSlug(value) {
   return CONFIG_HEALTH_FACADE_CHECK_SLUGS.includes(value);
 }
 
-// src/types/generated/activity_timeline.ts
-var ActivityActorKind = {
-  member: "member",
-  agent: "agent",
-  operator: "operator",
-  event_rule: "event_rule",
-  api_key: "api_key",
-  system: "system"
-};
-var ActivityAggregationKind = {
-  burst: "burst",
-  conversation_session: "conversation_session",
-  operation: "operation"
-};
-var ActivityCaptureState = {
-  active: "active",
-  not_started: "not_started"
-};
-var ActivityConfigAction = {
-  created: "created",
-  updated: "updated",
-  deleted: "deleted"
+// src/types/generated/ui_prompt.ts
+var UiPromptPresentedKind = {
+  render_ui: "render_ui",
+  present_choice_list: "present_choice_list",
+  inline_connect: "inline_connect"
 };
-var ActivityConfigArea = {
-  inbox: "inbox",
-  phone_number: "phone_number",
-  business_hours: "business_hours",
-  escalation_settings: "escalation_settings",
-  workspace_settings: "workspace_settings"
-};
-var ActivityCoverageLimitation = {
-  none: "none",
-  capture_started_at_cutover: "capture_started_at_cutover",
-  legacy_baseline_incomplete: "legacy_baseline_incomplete",
-  deletion_may_remove_history: "deletion_may_remove_history",
-  config_capture_started: "config_capture_started"
-};
-var ActivityDirection = {
-  inbound: "inbound",
-  outbound: "outbound"
+var UiPromptResponseKind = {
+  render_ui: "render_ui",
+  present_choice_list: "present_choice_list",
+  inline_connect: "inline_connect"
 };
-var ActivityEmptyReason = {
-  collection: "collection",
-  period: "period",
-  filtered: "filtered"
-};
-var ActivityEventType = {
-  workflow_started: "workflow_started",
-  assignment_task_transition: "assignment_task_transition",
-  journey_status_changed: "journey_status_changed",
-  journey_step_status_changed: "journey_step_status_changed",
-  journey_goal_status_changed: "journey_goal_status_changed",
-  chat_started: "chat_started",
-  message: "message",
-  call: "call",
-  form_field_changed: "form_field_changed",
-  config_changed: "config_changed"
-};
-var ActivityEventTypePreset = {
-  communications: "communications",
-  formUpdates: "formUpdates",
-  workflowTask: "workflowTask",
-  journey: "journey",
-  configuration: "configuration"
-};
-var ActivityGoalImpact = {
-  neutral: "neutral",
-  success: "success",
-  attention: "attention",
-  failure: "failure"
-};
-var ActivityTimelineProjection = {
-  timeline: "timeline"
-};
-var FormValueDisposition = {
-  shown: "shown",
-  omitted_long: "omitted_long",
-  omitted_structured: "omitted_structured",
-  omitted_burst: "omitted_burst"
+var UiPromptResponseStatus = {
+  submitted: "submitted",
+  declined: "declined"
 };
 
 // src/types/experiment-types.ts
@@ -8688,11 +9140,31 @@ var WorkspaceInvitationsApi = class extends BaseApiClient {
 };
 
 // src/api/workspaces.ts
+function planFields(options) {
+  if (!options) return {};
+  const fields = {};
+  if (options.intent !== void 0) fields.intent = options.intent;
+  if (options.expectedPlanFingerprint !== void 0) {
+    fields.expectedPlanFingerprint = options.expectedPlanFingerprint;
+  }
+  if (options.bindings !== void 0 && options.bindings.length > 0) {
+    fields.bindings = options.bindings;
+  }
+  return fields;
+}
 var WorkspacesApi = class extends BaseApiClient {
   /** List all workspaces accessible to the current user. */
   async getWorkspaces() {
     return this.fetch("w/");
   }
+  /**
+   * Compact rows for the workspaces a companion device could enter — the
+   * Lantern picker. Filtered by the same admission policy a device
+   * credential is gated by, without needing the device credential.
+   */
+  async getDeviceAdmissibleWorkspaces() {
+    return this.fetch("w/?can_use_device=1");
+  }
   /** List all publicly visible workspaces. */
   async getPublicWorkspaces() {
     return this.fetch("w/public");
@@ -8986,18 +9458,62 @@ var WorkspacesApi = class extends BaseApiClient {
     const qs = searchParams.toString();
     return this.fetch(`w/${wid}/export${qs ? `?${qs}` : ""}`);
   }
-  /** Preview the result of importing workspace configuration without applying changes. */
-  async previewWorkspaceImport(wid, exportData, importMappings, createNew, autoMap) {
+  /** Preview the result of importing workspace configuration without applying changes.
+   *
+   * Pass `options.intent = 'template_reapply'` to get the deterministic
+   * re-apply plan: `planRows`, `sourceFingerprint` and `planFingerprint` come
+   * back beside the legacy preview items, and the fingerprint is what
+   * `importWorkspace` must be given to apply exactly that projection.
+   */
+  async previewWorkspaceImport(wid, exportData, importMappings, createNew, autoMap, options) {
     return this.fetch(`w/${wid}/preview-import`, {
       method: "POST",
       body: JSON.stringify({
         exportData,
         importMappings,
         createNew,
-        autoMap
+        autoMap,
+        ...planFields(options)
       })
     });
   }
+  /**
+   * Plan a workspace export ZIP against this workspace without importing it.
+   *
+   * The sibling of `previewWorkspaceImport`, and it exists for one reason: a
+   * JSON preview has no archive, so it cannot decide whether File BYTES would
+   * be replaced — that decision compares the archive's blob digest against the
+   * destination's current content digest.
+   */
+  async previewWorkspaceImportZip(wid, archive, options) {
+    const { exportData, importMappings, createNew, autoMap, ...planOptions } = options ?? {};
+    const payload = {
+      importMappings: importMappings ?? {},
+      createNew: createNew ?? {},
+      ...planFields(planOptions)
+    };
+    if (exportData) payload.exportData = exportData;
+    if (autoMap) payload.autoMap = autoMap;
+    const form = new FormData();
+    form.append(
+      "request",
+      new Blob([JSON.stringify(payload)], { type: "application/json" }),
+      "import.json"
+    );
+    form.append("archive", archive, "workspace-export.zip");
+    return this.fetch(`w/${wid}/preview-import.zip`, {
+      method: "POST",
+      body: form
+    });
+  }
+  /**
+   * Everything a template re-apply adds to an import or a preview.
+   *
+   * `bindings` values are sent in the request body only. They are never
+   * projected from a response and must never be logged: the point of a
+   * binding is that a webhook endpoint and a signing secret belong to ONE
+   * target workspace.
+   */
   /** Download a workspace export ZIP (``export.json`` + file blobs). */
   async exportWorkspaceZip(wid, workflowId, scope, exclude) {
     const searchParams = new URLSearchParams();
@@ -9011,46 +9527,138 @@ var WorkspacesApi = class extends BaseApiClient {
   /** Import workspace configuration from exported JSON, or from a ZIP archive.
    * Pass ``archive`` (the ZIP from ``exportWorkspaceZip``) to restore file
    * contents. ``exportData`` may be omitted when the ZIP contains it.
-   */
-  async importWorkspace(wid, exportData, importMappings, createNew, archive) {
-    const payload = {
-      importMappings,
-      createNew
-    };
-    if (exportData) {
-      payload.exportData = exportData;
-    }
+   *
+   * ``activateWebhookRules`` is safety-default false: imported
+   * ``webhook:send`` EventRules are force-disabled unless the operator
+   * opts in. An exported-inactive rule stays inactive either way.
+   *
+   * With ``options.intent = 'template_reapply'`` this is the GUARDED apply.
+   * It requires ``options.expectedPlanFingerprint`` — the digest a preview
+   * returned — and answers 200 ``success``, 200 ``noop`` (the target already
+   * matched the template, so nothing at all was recorded), 409
+   * ``stale_import_plan`` or 409 ``import_plan_refused``. Both 409s commit
+   * nothing and carry the complete values-free ``planRows``.
+   */
+  async importWorkspace(wid, exportData, importMappings, createNew, archive, activateWebhookRules, autoMap, options) {
     if (archive) {
-      const form = new FormData();
-      form.append(
-        "request",
-        new Blob([JSON.stringify(payload)], { type: "application/json" }),
-        "import.json"
-      );
-      form.append("archive", archive, "workspace-export.zip");
-      return this.fetch(`w/${wid}/import.zip`, {
-        method: "POST",
-        body: form
+      return this.importWorkspaceZip(wid, archive, {
+        ...options,
+        exportData,
+        importMappings,
+        createNew,
+        autoMap,
+        activateWebhookRules
       });
     }
     if (!exportData) {
       throw new Error("exportData is required for JSON import");
     }
+    const payload = {
+      exportData,
+      importMappings,
+      createNew,
+      ...planFields(options)
+    };
+    if (activateWebhookRules) {
+      payload.activateWebhookRules = activateWebhookRules;
+    }
+    if (autoMap) {
+      payload.autoMap = autoMap;
+    }
     return this.fetch(`w/${wid}/import`, {
       method: "POST",
       body: JSON.stringify(payload)
     });
   }
+  /**
+   * Apply a workspace export ZIP to this workspace.
+   *
+   * The apply sibling of `previewWorkspaceImportZip`, and the same multipart
+   * shape: the archive travels as `archive`, everything else as one JSON
+   * `request` part. `exportData` defaults to `export.json` inside the ZIP, so
+   * it is sent only to override it.
+   *
+   * With `options.intent = 'template_reapply'` this is the GUARDED apply. It
+   * requires `options.expectedPlanFingerprint` — the digest a preview
+   * returned — and answers 200 `success`, 200 `noop` (the target already
+   * matched the template, so nothing at all was recorded), 409
+   * `stale_import_plan` or 409 `import_plan_refused`. Both 409s commit
+   * nothing and carry the complete values-free `planRows`.
+   *
+   * `options.bindings` values are sent in the request body only. They are
+   * never projected from a response and must never be logged: the point of a
+   * binding is that a webhook endpoint and a signing secret belong to ONE
+   * target workspace.
+   */
+  async importWorkspaceZip(wid, archive, options) {
+    const {
+      exportData,
+      importMappings,
+      createNew,
+      autoMap,
+      activateWebhookRules,
+      ...planOptions
+    } = options ?? {};
+    const payload = {
+      importMappings: importMappings ?? {},
+      createNew: createNew ?? {},
+      ...planFields(planOptions)
+    };
+    if (exportData) payload.exportData = exportData;
+    if (activateWebhookRules) payload.activateWebhookRules = activateWebhookRules;
+    if (autoMap) payload.autoMap = autoMap;
+    const form = new FormData();
+    form.append(
+      "request",
+      new Blob([JSON.stringify(payload)], { type: "application/json" }),
+      "import.json"
+    );
+    form.append("archive", archive, "workspace-export.zip");
+    return this.fetch(`w/${wid}/import.zip`, {
+      method: "POST",
+      body: form
+    });
+  }
+  /**
+   * Reconnectable EventRules skipped by the latest workspace import, grouped
+   * by the missing phone / inbox / member. Templates and action params are
+   * not returned.
+   */
+  async getImportSkippedRules(wid, status) {
+    const params = new URLSearchParams();
+    if (status !== void 0) {
+      params.set("status", status);
+    }
+    const qs = params.toString();
+    return this.fetch(
+      `w/${wid}/import/skipped-rules${qs ? `?${qs}` : ""}`
+    );
+  }
+  /** Current bounded phone, inbox, and phone-chat binding gaps after an import. */
+  async getImportReadiness(wid) {
+    return this.fetch(`w/${wid}/import/readiness`);
+  }
+  /**
+   * Re-point every outstanding skipped EventRule that needed the same source
+   * resource onto a re-provisioned one, recreating each rule from its
+   * preserved definition. Repeat calls no-op on already-reconnected rows.
+   */
+  async rebuildImportSkippedRules(wid, body) {
+    return this.fetch(
+      `w/${wid}/import/skipped-rules/rebuild`,
+      { method: "POST", body: JSON.stringify(body) }
+    );
+  }
   /** Preview a workspace import using the legacy untyped interface. */
   // Legacy method for backward compatibility
-  async previewImportWorkspace(wid, exportData, importMappings = {}, createNew = {}) {
+  async previewImportWorkspace(wid, exportData, importMappings = {}, createNew = {}, autoMap) {
+    const payload = { exportData, importMappings, createNew };
+    if (autoMap) {
+      payload.autoMap = autoMap;
+    }
     return this.fetch(`w/${wid}/preview-import`, {
       method: "POST",
-      body: JSON.stringify({
-        exportData,
-        importMappings,
-        createNew
-      })
+      body: JSON.stringify(payload)
     });
   }
   /** List available themes for a workspace. */
@@ -9165,36 +9773,35 @@ var DashboardsApi = class extends BaseApiClient {
 
 // src/api/devices.ts
 var DevicesApi = class extends BaseApiClient {
-  /** List devices visible to the caller (own devices, or all with devices:admin). */
-  async getDevices(wid, options = {}) {
-    const qs = options.mine ? "?mine=true" : "";
-    return this.fetch(`w/${wid}/devices${qs}`);
+  /** List devices owned by the current Account. */
+  async getDevices() {
+    return this.fetch("account/devices");
   }
-  /** Fetch one device by UUID. Non-owners without devices:admin receive 404. */
-  async getDevice(wid, deviceUuid) {
-    return this.fetch(`w/${wid}/devices/${deviceUuid}`);
+  /** Fetch one device owned by the current Account. Other devices return 404. */
+  async getDevice(deviceUuid) {
+    return this.fetch(`account/devices/${deviceUuid}`);
   }
   /** List shippable companion-device products (Lantern, later SKUs). */
-  async getDeviceKinds(wid) {
-    return this.fetch(`w/${wid}/devices/kinds`);
+  async getDeviceKinds() {
+    return this.fetch("account/devices/kinds");
   }
-  /** Claim a pairing code shown on a companion device. Requires devices:write. */
-  async claimDevicePairing(wid, body) {
-    return this.fetch(`w/${wid}/devices/pairing/claim`, {
+  /** Claim a pairing code shown on a companion device for the current Account. */
+  async claimDevicePairing(body) {
+    return this.fetch("account/devices/pairing/claim", {
       method: "POST",
       body: JSON.stringify(body)
     });
   }
-  /** Update display name and/or LAN capability flags. Requires devices:write. */
-  async updateDevice(wid, deviceUuid, body) {
-    return this.fetch(`w/${wid}/devices/${deviceUuid}`, {
+  /** Update display name and/or LAN capability flags on an owned device. */
+  async updateDevice(deviceUuid, body) {
+    return this.fetch(`account/devices/${deviceUuid}`, {
       method: "PATCH",
       body: JSON.stringify(body)
     });
   }
-  /** Revoke a device credential. The device must pair again. Requires devices:write. */
-  async revokeDevice(wid, deviceUuid) {
-    return this.fetch(`w/${wid}/devices/${deviceUuid}/revoke`, {
+  /** Revoke an owned device credential. The device must pair again. */
+  async revokeDevice(deviceUuid) {
+    return this.fetch(`account/devices/${deviceUuid}/revoke`, {
       method: "POST",
       body: JSON.stringify({})
     });
@@ -9375,11 +9982,155 @@ var PatientSyncConnectionsApi = class extends BaseApiClient {
   }
 };
 
-// src/api/activity-timeline.ts
-var ActivityTimelineApi = class extends BaseApiClient {
-  /** One page of activity. Omit `cursor` for a fresh snapshot. */
-  async queryActivityTimeline(wid, request = {}) {
-    return this.fetch(`w/${wid}/activity-timeline/query`, {
+// src/api/activity.ts
+var ActivityApi = class extends BaseApiClient {
+  /** The account mount: this caller's whole estate, at any grain. */
+  async queryActivity(request) {
+    return this.fetch("activity/query", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Latest admitted event for each workspace-qualified Activity subject.
+   * Scope authorization and any event-type leaf authorization are both
+   * applied before a subject is returned.
+   */
+  async queryActivityLatestSubjects(request) {
+    return this.fetch("activity/latest-subjects", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * The account mount's priority lane — one queue per human. `openedAfter`
+   * may bound the active backlog without changing the priority policy.
+   */
+  async queryActivityOpenItems(request = {}) {
+    return this.fetch("activity/open-items", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * The account mount's one view: one stream of occurrences, some carrying
+   * open state. The window bounds the event axis; open items older than it
+   * arrive as `olderOpenCount`, never hidden.
+   */
+  async queryActivityOneView(request) {
+    return this.fetch("activity/one-view", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The account mount's badge numbers. */
+  async getActivityCounts(request = {}) {
+    return this.fetch("activity/counts", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * What this caller's estate admits, so a client renders honest controls.
+   *
+   * Account mount only, and deliberately so: the org and workspace mounts
+   * answer the same question through the surfaces that already serve their
+   * membership. Not an authorization decision — every read re-derives that.
+   */
+  async getActivityCapabilities() {
+    return this.fetch("activity/capabilities", { method: "GET" });
+  }
+  /** The org mount. `org:info` is the entry gate; `org:read` widens the rows. */
+  async queryOrgActivity(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/query`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async queryOrgActivityLatestSubjects(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/latest-subjects`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The org mount's priority lane. */
+  async queryOrgActivityOpenItems(orgUuid, request = {}) {
+    return this.fetch(`o/${orgUuid}/activity/open-items`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The org mount's one view. */
+  async queryOrgActivityOneView(orgUuid, request) {
+    return this.fetch(`o/${orgUuid}/activity/one-view`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The org mount's badge numbers. */
+  async getOrgActivityCounts(orgUuid, request = {}) {
+    return this.fetch(`o/${orgUuid}/activity/counts`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount. The request's own member session carries its scopes. */
+  async queryWorkspaceActivity(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/activity/query`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async queryWorkspaceActivityLatestSubjects(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/activity/latest-subjects`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount's priority lane. */
+  async queryWorkspaceActivityOpenItems(workspaceUuid, request = {}) {
+    return this.fetch(`w/${workspaceUuid}/activity/open-items`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount's one view. */
+  async queryWorkspaceActivityOneView(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/activity/one-view`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /** The workspace mount's badge numbers. */
+  async getWorkspaceActivityCounts(workspaceUuid, request = {}) {
+    return this.fetch(`w/${workspaceUuid}/activity/counts`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Hydrate a page of typed refs in one round trip.
+   *
+   * The relief valve the design names for chatty hydration, and the by-UUID
+   * read path most entity kinds otherwise lack: nineteen kinds resolve here,
+   * each through the workspace's own live authorizers under the caller's
+   * session. One request per workspace per listing, instead of one per ref.
+   *
+   * **Every requested ref comes back**, in the order it was sent and
+   * deduplicated on `(kind, uuid)`. A ref the caller may not see is an entry
+   * with `status: 'unresolved'` — never a 404, and never an omission, so a
+   * page's ability to render never depends on what it happens to name.
+   * `status: 'unsupported'` means this build has no by-UUID path for that
+   * kind at all (account, org, workspace, domain, subscription and the
+   * commerce kinds; see the resolve registry for each one's reason) — those
+   * resolve through the mount that owns them, and retrying here will not
+   * help.
+   *
+   * PHI: resolved labels are member-identifying data. They belong in the UI
+   * and nowhere else — never a log line, never an error message.
+   */
+  async resolveEntityRefs(workspaceUuid, request) {
+    return this.fetch(`w/${workspaceUuid}/entity-refs/resolve`, {
       method: "POST",
       body: JSON.stringify(request)
     });
@@ -9407,6 +10158,10 @@ var MotdApi = class extends BaseApiClient {
 
 // src/api/intervention-requests.ts
 var InterventionRequestsApi = class extends BaseApiClient {
+  /** List every visible Chat that currently needs attention in Agent Mode. */
+  async getAgentModeAttention(wid) {
+    return this.fetch(`w/${wid}/agent-mode/attention`);
+  }
   /** List intervention requests in a workspace, newest first. */
   async getInterventionRequests(wid, params = {}) {
     const query = new URLSearchParams();
@@ -9420,6 +10175,23 @@ var InterventionRequestsApi = class extends BaseApiClient {
       `w/${wid}/intervention-requests${qs ? `?${qs}` : ""}`
     );
   }
+  /**
+   * Resolve one intervention request. One row, one resolution — whoever takes
+   * it closes it for everyone who was notified. Resolving an already-resolved
+   * request is a 409 conflict; a non-escalation request is a 409 too.
+   *
+   * The JSON body (empty when no note is supplied) is required as a CSRF
+   * barrier (GRA-6284), so a cross-site form POST cannot reach it.
+   */
+  async resolveInterventionRequest(wid, requestId, params = {}) {
+    return this.fetch(
+      `w/${wid}/intervention-requests/${requestId}/resolve`,
+      {
+        method: "POST",
+        body: JSON.stringify(params)
+      }
+    );
+  }
 };
 
 // src/api/metrics.ts
@@ -9738,7 +10510,7 @@ function createApiModules(apiKey, baseUrl, customFetch) {
     connectionSync: new ConnectionSyncApi(apiKey, baseUrl, customFetch),
     mcpServers: new McpServersApi(apiKey, baseUrl, customFetch),
     members: new MembersApi(apiKey, baseUrl, customFetch),
-    activityTimeline: new ActivityTimelineApi(apiKey, baseUrl, customFetch),
+    activity: new ActivityApi(apiKey, baseUrl, customFetch),
     motd: new MotdApi(apiKey, baseUrl, customFetch),
     trackedLinks: new TrackedLinksApi(apiKey, baseUrl, customFetch),
     confluence: new ConfluenceApi(apiKey, baseUrl, customFetch),
@@ -9785,6 +10557,8 @@ var WORKSPACE_METHOD_NAMES = [
   "archiveDataType",
   "archiveJourney",
   "archiveMember",
+  "archiveMemberRelationship",
+  "archivePersona",
   "archivePhoneNumber",
   "archiveStep",
   "archiveTask",
@@ -9837,6 +10611,8 @@ var WORKSPACE_METHOD_NAMES = [
   "createCalendarEventType",
   "createCalendarSchedule",
   "createChat",
+  "createChatInteractionSession",
+  "transitionChatInteractionSession",
   "createChatCompletion",
   "createChatFilter",
   "createChatLabel",
@@ -9866,6 +10642,7 @@ var WORKSPACE_METHOD_NAMES = [
   "createMemberFilter",
   "createMemberLabel",
   "createMemberMemory",
+  "createMemberRelationship",
   "createMemberRole",
   "createMenuItem",
   "createNotificationRule",
@@ -9968,7 +10745,6 @@ var WORKSPACE_METHOD_NAMES = [
   "disconnectConfluence",
   "disconnectHubspot",
   "disconnectMondayConnection",
-  "disconnectPresence",
   "disconnectSalesforce",
   "discordLinkPreflight",
   "discoverOAuthMetadata",
@@ -10031,6 +10807,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getAccessGrant",
   "getAccessGrants",
   "getAgent",
+  "getAgentModeAttention",
   "getAgentTask",
   "getAgentTaskMessages",
   "getAgentTasks",
@@ -10062,7 +10839,9 @@ var WORKSPACE_METHOD_NAMES = [
   "getCharlestonTestDeliveryRecipients",
   "getChat",
   "getChatAssignmentTasks",
+  "getChatBrowserLiveView",
   "getChatCallbacks",
+  "getChatEhrWritebackOutcomes",
   "getChatEmails",
   "getChatFilter",
   "getChatFilterByUuid",
@@ -10071,6 +10850,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getChatLabel",
   "getChatLabelByUuid",
   "getChatLabels",
+  "getChatMachineResources",
   "getChatMessages",
   "getChatModelOverride",
   "getChatPhoneCalls",
@@ -10111,6 +10891,8 @@ var WORKSPACE_METHOD_NAMES = [
   "getDataRecordFilters",
   "getDataRecords",
   "getDataType",
+  "getDataTypeDraft",
+  "getDataTypeVersions",
   "getDataTypeByUuid",
   "getDataTypeBySlug",
   "getDataTypes",
@@ -10154,9 +10936,15 @@ var WORKSPACE_METHOD_NAMES = [
   "listChatRecordings",
   "previewQuery",
   "publishSiteSource",
-  "queryActivityTimeline",
+  "publishDataTypeDraft",
+  "saveDataTypeDraft",
+  "queryWorkspaceActivity",
+  "queryWorkspaceActivityLatestSubjects",
+  "queryWorkspaceActivityOpenItems",
+  "queryWorkspaceActivityOneView",
   "registerDiscordSlashCommands",
   "reopenWorkspaceSupportRequest",
+  "resolveEntityRefs",
   "resetSiteSource",
   "resolveFilePath",
   "getFileLabel",
@@ -10184,16 +10972,22 @@ var WORKSPACE_METHOD_NAMES = [
   "getHubspotSyncLogs",
   "getHubspotTransformPresets",
   "getICalFeedUrl",
+  "getImportSkippedRules",
+  "getImportReadiness",
+  "rebuildImportSkippedRules",
   "getInbox",
   "getInboxEmail",
   "getInboxEmails",
   "getInboxThreads",
   "getInboxes",
+  "getInterventionRequests",
   "getJourney",
   "getJourneyAuthoring",
+  "getJourneyFilterOptions",
   "getJourneyHealth",
   "getJourneyMembers",
   "getJourneyNotes",
+  "getJourneyV2Validation",
   "getJourneys",
   "getLinkablePhones",
   "getLinkedHealthieMembers",
@@ -10221,6 +11015,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getMemberMemories",
   "getMemberMemory",
   "getMemberRecordCounts",
+  "getMemberRelationships",
   "getMemberRole",
   "getMemberRoleCleanupPlan",
   "getMemberRoleByUuid",
@@ -10269,8 +11064,6 @@ var WORKSPACE_METHOD_NAMES = [
   "getPublicFolder",
   "getPublicFolderFiles",
   "getPublicProducts",
-  "previewPromoCode",
-  "startPromoPlanTrial",
   "getQualification",
   "getQualifications",
   "getRecordingInfo",
@@ -10325,10 +11118,10 @@ var WORKSPACE_METHOD_NAMES = [
   "getUnreadNotificationCount",
   "getUsageDashboard",
   "getVariableRegistry",
-  "getVoiceToken",
   "getVoiceUsageReport",
   "getWebhookLogs",
   "getWorkflow",
+  "getWorkflowOpeningTurnConversionReport",
   "getWorkflowAccessValidation",
   "getWorkflowActivity",
   "getWorkflowConfigValidation",
@@ -10345,6 +11138,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getWorkflows",
   "getWorkflowsActivityBatch",
   "getWorkspace",
+  "getWorkspaceActivityCounts",
   "getWorkspaceBuilder",
   "getWorkspaceBuilders",
   "getWorkspaceCounts",
@@ -10364,7 +11158,7 @@ var WORKSPACE_METHOD_NAMES = [
   "importMembers",
   "importSalesforceMembers",
   "importWorkspace",
-  "initiateCall",
+  "importWorkspaceZip",
   "initiateOutboundCall",
   "inspectPrompt",
   "installHubspot",
@@ -10421,14 +11215,17 @@ var WORKSPACE_METHOD_NAMES = [
   "previewMemberWorkflowVoice",
   "previewRenameFieldSlug",
   "previewImportWorkspace",
+  "previewRoutineVoiceReadiness",
   "previewRoutineWorkflowAccess",
   "previewSchedule",
   "previewTTS",
   "previewTemplate",
   "previewThinkingSound",
   "previewWorkspaceImport",
+  "previewWorkspaceImportZip",
   "provisionClientWorkspace",
   "publishWorkflowRevision",
+  "putJourneyV2Definition",
   "rateMessage",
   "getChatFeedback",
   "reenrollMember",
@@ -10449,6 +11246,7 @@ var WORKSPACE_METHOD_NAMES = [
   "resetRoutineRuns",
   "resolveAccessGrant",
   "resolveAnonymousMember",
+  "resolveInterventionRequest",
   "restoreFileVersion",
   "revokeAccessGrant",
   "revokeApiKey",
@@ -10462,6 +11260,7 @@ var WORKSPACE_METHOD_NAMES = [
   "selectCurrentAssignmentTask",
   "sendAssistantMessage",
   "sendChatMessage",
+  "sendInboxEmail",
   "sendOperatorMessage",
   "siteGoogleOAuthInitiate",
   "siteSendEmailCode",
@@ -10488,6 +11287,7 @@ var WORKSPACE_METHOD_NAMES = [
   "unarchiveChat",
   "unarchiveDataType",
   "unarchiveMember",
+  "unarchivePersona",
   "unarchiveStep",
   "unarchiveTask",
   "unarchiveWorkflow",
@@ -10576,6 +11376,7 @@ var WORKSPACE_METHOD_NAMES = [
   "uploadFile",
   "updateVoicemailStatus",
   "updateWorkflow",
+  "convertWorkflowStartTaskOpeningMessage",
   "updateWorkflowContributor",
   "updateWorkflowNote",
   "updateWorkflowRevisionMetadata",
@@ -10622,6 +11423,13 @@ function bindAccessGrantsMethods(target, accessGrants) {
   target.getGranteeGrants = accessGrants.getGranteeGrants.bind(accessGrants);
 }
 
+// src/client/bindings/intervention-requests.ts
+function bindInterventionRequestsMethods(target, interventionRequests) {
+  target.getAgentModeAttention = interventionRequests.getAgentModeAttention.bind(interventionRequests);
+  target.getInterventionRequests = interventionRequests.getInterventionRequests.bind(interventionRequests);
+  target.resolveInterventionRequest = interventionRequests.resolveInterventionRequest.bind(interventionRequests);
+}
+
 // src/client/bindings/agent-tasks.ts
 function bindAgentTasksMethods(target, api) {
   target.getAgentTasks = api.getAgentTasks.bind(api);
@@ -10662,10 +11470,15 @@ function bindTasksMethods(target, tasks, abilities) {
 
 // src/client/bindings/chats.ts
 function bindChatsMethods(target, chats) {
+  target.createChatInteractionSession = chats.createChatInteractionSession.bind(chats);
+  target.transitionChatInteractionSession = chats.transitionChatInteractionSession.bind(chats);
   target.getChats = chats.getChats.bind(chats);
   target.getChat = chats.getChat.bind(chats);
+  target.getChatBrowserLiveView = chats.getChatBrowserLiveView.bind(chats);
+  target.getChatMachineResources = chats.getChatMachineResources.bind(chats);
   target.getCurrentSmsChat = chats.getCurrentSmsChat.bind(chats);
   target.getChatCallbacks = chats.getChatCallbacks.bind(chats);
+  target.getChatEhrWritebackOutcomes = chats.getChatEhrWritebackOutcomes.bind(chats);
   target.cancelChatCallback = chats.cancelChatCallback.bind(chats);
   target.getChatTokenUsage = chats.getChatTokenUsage.bind(chats);
   target.getChatTodos = chats.getChatTodos.bind(chats);
@@ -10718,8 +11531,6 @@ function bindChatsMethods(target, chats) {
 // src/client/bindings/calls.ts
 function bindCallsMethods(target, calls, cel) {
   target.getPhoneCalls = calls.getPhoneCalls.bind(calls);
-  target.initiateCall = calls.initiateCall.bind(calls);
-  target.getVoiceToken = calls.getVoiceToken.bind(calls);
   target.getMessageTiming = calls.getMessageTiming.bind(calls);
   target.getRecordingInfo = calls.getRecordingInfo.bind(calls);
   target.listChatRecordings = calls.listChatRecordings.bind(calls);
@@ -10740,9 +11551,25 @@ function bindDashboardsMethods(target, dashboards) {
   target.getConfigurationHealth = dashboards.getConfigurationHealth.bind(dashboards);
 }
 
-// src/client/bindings/activity-timeline.ts
-function bindActivityTimelineMethods(target, activityTimeline) {
-  target.queryActivityTimeline = activityTimeline.queryActivityTimeline.bind(activityTimeline);
+// src/client/bindings/activity.ts
+function bindActivityMethods(target, activity) {
+  target.queryActivity = activity.queryActivity.bind(activity);
+  target.queryActivityLatestSubjects = activity.queryActivityLatestSubjects.bind(activity);
+  target.queryActivityOpenItems = activity.queryActivityOpenItems.bind(activity);
+  target.queryActivityOneView = activity.queryActivityOneView.bind(activity);
+  target.getActivityCounts = activity.getActivityCounts.bind(activity);
+  target.getActivityCapabilities = activity.getActivityCapabilities.bind(activity);
+  target.queryOrgActivity = activity.queryOrgActivity.bind(activity);
+  target.queryOrgActivityLatestSubjects = activity.queryOrgActivityLatestSubjects.bind(activity);
+  target.queryOrgActivityOpenItems = activity.queryOrgActivityOpenItems.bind(activity);
+  target.queryOrgActivityOneView = activity.queryOrgActivityOneView.bind(activity);
+  target.getOrgActivityCounts = activity.getOrgActivityCounts.bind(activity);
+  target.queryWorkspaceActivity = activity.queryWorkspaceActivity.bind(activity);
+  target.queryWorkspaceActivityLatestSubjects = activity.queryWorkspaceActivityLatestSubjects.bind(activity);
+  target.queryWorkspaceActivityOpenItems = activity.queryWorkspaceActivityOpenItems.bind(activity);
+  target.queryWorkspaceActivityOneView = activity.queryWorkspaceActivityOneView.bind(activity);
+  target.getWorkspaceActivityCounts = activity.getWorkspaceActivityCounts.bind(activity);
+  target.resolveEntityRefs = activity.resolveEntityRefs.bind(activity);
 }
 
 // src/client/bindings/motd.ts
@@ -10764,6 +11591,10 @@ function bindTrackedLinksMethods(target, trackedLinks) {
 
 // src/client/bindings/data-types.ts
 function bindDataTypesMethods(target, dataTypes) {
+  target.getDataTypeDraft = dataTypes.getDataTypeDraft.bind(dataTypes);
+  target.saveDataTypeDraft = dataTypes.saveDataTypeDraft.bind(dataTypes);
+  target.publishDataTypeDraft = dataTypes.publishDataTypeDraft.bind(dataTypes);
+  target.getDataTypeVersions = dataTypes.getDataTypeVersions.bind(dataTypes);
   target.getDataTypes = dataTypes.getDataTypes.bind(dataTypes);
   target.getDataType = dataTypes.getDataType.bind(dataTypes);
   target.getDataTypeByUuid = dataTypes.getDataTypeByUuid.bind(dataTypes);
@@ -10849,6 +11680,8 @@ function bindMembersMethods(target, members) {
   target.createMemberRole = members.createMemberRole.bind(members);
   target.updateMemberRole = members.updateMemberRole.bind(members);
   target.deleteMemberRole = members.deleteMemberRole.bind(members);
+  target.getMemberRoleCleanupPlan = members.getMemberRoleCleanupPlan.bind(members);
+  target.mergeMemberRoles = members.mergeMemberRoles.bind(members);
   target.getMemberFields = members.getMemberFields.bind(members);
   target.getMemberFieldDefinitions = members.getMemberFieldDefinitions.bind(members);
   target.createMemberField = members.createMemberField.bind(members);
@@ -10866,11 +11699,15 @@ function bindMembersMethods(target, members) {
   target.createMemberMemory = members.createMemberMemory.bind(members);
   target.deleteMemberMemory = members.deleteMemberMemory.bind(members);
   target.getMemberSyncLinks = members.getMemberSyncLinks.bind(members);
+  target.getMemberRelationships = members.getMemberRelationships.bind(members);
+  target.createMemberRelationship = members.createMemberRelationship.bind(members);
+  target.archiveMemberRelationship = members.archiveMemberRelationship.bind(members);
 }
 
 // src/client/bindings/workspaces.ts
 function bindWorkspacesMethods(target, workspaces, signupRequests) {
   target.getWorkspaces = workspaces.getWorkspaces.bind(workspaces);
+  target.getDeviceAdmissibleWorkspaces = workspaces.getDeviceAdmissibleWorkspaces.bind(workspaces);
   target.getPublicWorkspaces = workspaces.getPublicWorkspaces.bind(workspaces);
   target.getWorkspace = workspaces.getWorkspace.bind(workspaces);
   target.createWorkspace = workspaces.createWorkspace.bind(workspaces);
@@ -10901,6 +11738,8 @@ function bindWorkspacesMethods(target, workspaces, signupRequests) {
   target.getProduct = workspaces.getProduct.bind(workspaces);
   target.getWorkspaceProduct = workspaces.getWorkspaceProduct.bind(workspaces);
   target.getPublicProducts = workspaces.getPublicProducts.bind(workspaces);
+  target.previewPromoCode = workspaces.previewPromoCode.bind(workspaces);
+  target.startPromoPlanTrial = workspaces.startPromoPlanTrial.bind(workspaces);
   target.getPublicProduct = workspaces.getPublicProduct.bind(workspaces);
   target.createProduct = workspaces.createProduct.bind(workspaces);
   target.updateProduct = workspaces.updateProduct.bind(workspaces);
@@ -10908,7 +11747,12 @@ function bindWorkspacesMethods(target, workspaces, signupRequests) {
   target.exportWorkspace = workspaces.exportWorkspace.bind(workspaces);
   target.exportWorkspaceZip = workspaces.exportWorkspaceZip.bind(workspaces);
   target.previewWorkspaceImport = workspaces.previewWorkspaceImport.bind(workspaces);
+  target.previewWorkspaceImportZip = workspaces.previewWorkspaceImportZip.bind(workspaces);
   target.importWorkspace = workspaces.importWorkspace.bind(workspaces);
+  target.importWorkspaceZip = workspaces.importWorkspaceZip.bind(workspaces);
+  target.getImportSkippedRules = workspaces.getImportSkippedRules.bind(workspaces);
+  target.getImportReadiness = workspaces.getImportReadiness.bind(workspaces);
+  target.rebuildImportSkippedRules = workspaces.rebuildImportSkippedRules.bind(workspaces);
   target.previewImportWorkspace = workspaces.previewImportWorkspace.bind(workspaces);
   target.getWorkspaceThemes = workspaces.getWorkspaceThemes.bind(workspaces);
   target.updateWorkspaceThemes = workspaces.updateWorkspaceThemes.bind(workspaces);
@@ -11116,9 +11960,11 @@ function bindEventsMethods(target, events) {
   target.updateRoutine = events.updateRoutine.bind(events);
   target.deleteRoutine = events.deleteRoutine.bind(events);
   target.runRoutine = events.runRoutine.bind(events);
+  target.getRoutineConfigEvents = events.getRoutineConfigEvents.bind(events);
   target.getRoutineRuns = events.getRoutineRuns.bind(events);
   target.resetRoutineRuns = events.resetRoutineRuns.bind(events);
   target.previewSchedule = events.previewSchedule.bind(events);
+  target.previewRoutineVoiceReadiness = events.previewRoutineVoiceReadiness.bind(events);
   target.previewRoutineWorkflowAccess = events.previewRoutineWorkflowAccess.bind(events);
 }
 
@@ -11143,6 +11989,8 @@ function bindExperimentsMethods(target, experiments) {
 function bindWorkflowsMethods(target, workflows, workflowNotes, voice, supervisors) {
   target.getWorkflows = workflows.getWorkflows.bind(workflows);
   target.getWorkflow = workflows.getWorkflow.bind(workflows);
+  target.getWorkflowOpeningTurnConversionReport = workflows.getWorkflowOpeningTurnConversionReport.bind(workflows);
+  target.convertWorkflowStartTaskOpeningMessage = workflows.convertWorkflowStartTaskOpeningMessage.bind(workflows);
   target.getWorkflowActivity = workflows.getWorkflowActivity.bind(workflows);
   target.getWorkflowsActivityBatch = workflows.getWorkflowsActivityBatch.bind(workflows);
   target.getWorkflowDiagram = workflows.getWorkflowDiagram.bind(workflows);
@@ -11262,6 +12110,7 @@ function bindCommunicationsMethods(target, phoneNumbers, inboxes, notificationRu
   target.getThreadEmails = inboxes.getThreadEmails.bind(inboxes);
   target.getChatEmails = inboxes.getChatEmails.bind(inboxes);
   target.replyToEmail = inboxes.replyToEmail.bind(inboxes);
+  target.sendInboxEmail = inboxes.sendInboxEmail.bind(inboxes);
   target.getNotificationRules = notificationRules.getNotificationRules.bind(notificationRules);
   target.createNotificationRule = notificationRules.createNotificationRule.bind(notificationRules);
   target.updateNotificationRule = notificationRules.updateNotificationRule.bind(notificationRules);
@@ -11562,7 +12411,6 @@ function bindOperatorMethods(target, operatorGroups) {
   target.removeGroupMember = operatorGroups.removeGroupMember.bind(operatorGroups);
   target.getLiveOperators = operatorGroups.getLiveOperators.bind(operatorGroups);
   target.getPresenceStatus = operatorGroups.getPresenceStatus.bind(operatorGroups);
-  target.disconnectPresence = operatorGroups.disconnectPresence.bind(operatorGroups);
   target.getOperatorChatMessages = operatorGroups.getOperatorChatMessages.bind(operatorGroups);
   target.sendOperatorMessage = operatorGroups.sendOperatorMessage.bind(operatorGroups);
 }
@@ -11590,10 +12438,14 @@ function bindOrgMethods(target, org) {
   target.listLegalEntities = org.listLegalEntities.bind(org);
   target.getLegalEntity = org.getLegalEntity.bind(org);
   target.createLegalEntity = org.createLegalEntity.bind(org);
+  target.getRegistrationDraft = org.getRegistrationDraft.bind(org);
+  target.saveRegistrationDraft = org.saveRegistrationDraft.bind(org);
   target.getVoiceTrustProducts = org.getVoiceTrustProducts.bind(org);
   target.syncVoiceTrustProducts = org.syncVoiceTrustProducts.bind(org);
   target.createOrganizationWorkspace = org.createOrganizationWorkspace.bind(org);
   target.getOrgBillingCustomer = org.getOrgBillingCustomer.bind(org);
+  target.getA2PCampaignConfig = org.getA2PCampaignConfig.bind(org);
+  target.updateA2PCampaignConfig = org.updateA2PCampaignConfig.bind(org);
   target.getOrgWorkspaceUsage = org.getOrgWorkspaceUsage.bind(org);
 }
 
@@ -11619,6 +12471,9 @@ function bindJourneysMethods(target, journeys) {
   target.getJourneys = journeys.getJourneys.bind(journeys);
   target.getJourney = journeys.getJourney.bind(journeys);
   target.getJourneyAuthoring = journeys.getJourneyAuthoring.bind(journeys);
+  target.putJourneyV2Definition = journeys.putJourneyV2Definition.bind(journeys);
+  target.getJourneyV2Validation = journeys.getJourneyV2Validation.bind(journeys);
+  target.getJourneyFilterOptions = journeys.getJourneyFilterOptions.bind(journeys);
   target.getJourneyHealth = journeys.getJourneyHealth.bind(journeys);
   target.createJourney = journeys.createJourney.bind(journeys);
   target.updateJourney = journeys.updateJourney.bind(journeys);
@@ -11674,6 +12529,8 @@ function bindPersonasMethods(target, personas) {
   target.getPersona = personas.getPersona.bind(personas);
   target.createPersona = personas.createPersona.bind(personas);
   target.updatePersona = personas.updatePersona.bind(personas);
+  target.archivePersona = personas.archivePersona.bind(personas);
+  target.unarchivePersona = personas.unarchivePersona.bind(personas);
   target.deletePersona = personas.deletePersona.bind(personas);
 }
 
@@ -11773,8 +12630,11 @@ var GravityRailClient = class {
   // Chats API
   getChats;
   getChat;
+  getChatBrowserLiveView;
+  getChatMachineResources;
   getCurrentSmsChat;
   getChatCallbacks;
+  getChatEhrWritebackOutcomes;
   cancelChatCallback;
   getChatTokenUsage;
   getChatTodos;
@@ -11786,6 +12646,8 @@ var GravityRailClient = class {
   archiveChat;
   unarchiveChat;
   createChat;
+  createChatInteractionSession;
+  transitionChatInteractionSession;
   createWorkflowOutboundVoiceChat;
   deleteChat;
   updateChat;
@@ -11824,8 +12686,6 @@ var GravityRailClient = class {
   getChatFilterCount;
   // Calls API
   getPhoneCalls;
-  initiateCall;
-  getVoiceToken;
   getMessageTiming;
   getRecordingInfo;
   listChatRecordings;
@@ -11834,6 +12694,10 @@ var GravityRailClient = class {
   validateCelExpression;
   // Data Types API
   getDataTypes;
+  getDataTypeDraft;
+  saveDataTypeDraft;
+  publishDataTypeDraft;
+  getDataTypeVersions;
   getDataType;
   getDataTypeByUuid;
   getDataTypeBySlug;
@@ -11929,6 +12793,10 @@ var GravityRailClient = class {
   deleteMemberMemory;
   // Member Sync Links
   getMemberSyncLinks;
+  // Member Relationships
+  getMemberRelationships;
+  createMemberRelationship;
+  archiveMemberRelationship;
   // Agent Tasks API (operator-facing async sub-agent inspection/cancel)
   getAgentTasks;
   getAgentTask;
@@ -11966,6 +12834,8 @@ var GravityRailClient = class {
   getPersona;
   createPersona;
   updatePersona;
+  archivePersona;
+  unarchivePersona;
   deletePersona;
   // Metrics API (customer-defined outcome metrics)
   listMetrics;
@@ -11985,8 +12855,26 @@ var GravityRailClient = class {
   getDashboardChannelStats;
   getDashboardWorkflowAssignmentStats;
   getConfigurationHealth;
-  // Activity Timeline API
-  queryActivityTimeline;
+  // Activity Spine serving API — one query shape, three mounts
+  // (docs/projects/active/activity-spine.md).
+  queryActivity;
+  queryActivityLatestSubjects;
+  queryActivityOpenItems;
+  queryActivityOneView;
+  getActivityCounts;
+  getActivityCapabilities;
+  queryOrgActivity;
+  queryOrgActivityLatestSubjects;
+  queryOrgActivityOpenItems;
+  queryOrgActivityOneView;
+  getOrgActivityCounts;
+  queryWorkspaceActivity;
+  queryWorkspaceActivityLatestSubjects;
+  queryWorkspaceActivityOpenItems;
+  queryWorkspaceActivityOneView;
+  getWorkspaceActivityCounts;
+  // Hydration: typed refs in, display summaries out, one round trip.
+  resolveEntityRefs;
   // MOTD API
   getMotd;
   // Tracked Links analytics (#10934)
@@ -12002,6 +12890,9 @@ var GravityRailClient = class {
   getJourneys;
   getJourney;
   getJourneyAuthoring;
+  putJourneyV2Definition;
+  getJourneyV2Validation;
+  getJourneyFilterOptions;
   getJourneyHealth;
   createJourney;
   updateJourney;
@@ -12056,7 +12947,6 @@ var GravityRailClient = class {
   removeGroupMember;
   getLiveOperators;
   getPresenceStatus;
-  disconnectPresence;
   getOperatorChatMessages;
   sendOperatorMessage;
   // Access Grants API
@@ -12069,10 +12959,15 @@ var GravityRailClient = class {
   getAccessGrants;
   getMemberGrants;
   getGranteeGrants;
+  // Intervention Requests API
+  getAgentModeAttention;
+  getInterventionRequests;
+  resolveInterventionRequest;
   // Prompts API
   inspectPrompt;
   // Workspaces API
   getWorkspaces;
+  getDeviceAdmissibleWorkspaces;
   getPublicWorkspaces;
   getWorkspace;
   createWorkspace;
@@ -12112,7 +13007,12 @@ var GravityRailClient = class {
   exportWorkspace;
   exportWorkspaceZip;
   previewWorkspaceImport;
+  previewWorkspaceImportZip;
   importWorkspace;
+  importWorkspaceZip;
+  getImportSkippedRules;
+  getImportReadiness;
+  rebuildImportSkippedRules;
   previewImportWorkspace;
   getWorkspaceThemes;
   updateWorkspaceThemes;
@@ -12147,10 +13047,14 @@ var GravityRailClient = class {
   listLegalEntities;
   getLegalEntity;
   createLegalEntity;
+  getRegistrationDraft;
+  saveRegistrationDraft;
   getVoiceTrustProducts;
   syncVoiceTrustProducts;
   createOrganizationWorkspace;
   getOrgBillingCustomer;
+  getA2PCampaignConfig;
+  updateA2PCampaignConfig;
   getOrgWorkspaceUsage;
   getVapidPublicKey;
   registerPushSubscription;
@@ -12336,10 +13240,13 @@ var GravityRailClient = class {
   getRoutineRuns;
   resetRoutineRuns;
   previewSchedule;
+  previewRoutineVoiceReadiness;
   previewRoutineWorkflowAccess;
   // Workflows API
   getWorkflows;
   getWorkflow;
+  getWorkflowOpeningTurnConversionReport;
+  convertWorkflowStartTaskOpeningMessage;
   getWorkflowActivity;
   getWorkflowsActivityBatch;
   getWorkflowDiagram;
@@ -12453,6 +13360,7 @@ var GravityRailClient = class {
   getThreadEmails;
   getChatEmails;
   replyToEmail;
+  sendInboxEmail;
   getNotificationRules;
   createNotificationRule;
   updateNotificationRule;
@@ -12814,7 +13722,7 @@ var GravityRailClient = class {
     bindMetricsMethods(this, apis.metrics);
     bindQueriesMethods(this, apis.queries);
     bindDashboardsMethods(this, apis.dashboards);
-    bindActivityTimelineMethods(this, apis.activityTimeline);
+    bindActivityMethods(this, apis.activity);
     bindMotdMethods(this, apis.motd);
     bindTrackedLinksMethods(this, apis.trackedLinks);
     bindJourneysMethods(this, apis.journeys);
@@ -12822,6 +13730,7 @@ var GravityRailClient = class {
     bindOperatorMethods(this, apis.operatorGroups);
     bindOrgMethods(this, apis.org);
     bindAccessGrantsMethods(this, apis.accessGrants);
+    bindInterventionRequestsMethods(this, apis.interventionRequests);
     bindPromptsMethods(this, apis.prompts);
     bindWorkspacesMethods(this, apis.workspaces, apis.workspaceInvitations);
     bindAuthMethods(this, apis.auth, apis.assignments);
@@ -13054,6 +13963,30 @@ var QUERY_VALUELESS_OPS = /* @__PURE__ */ new Set([
   "exists"
 ]);
 
+// src/types/generated/channel_message.ts
+var ChannelMessageDirection = {
+  inbound: "inbound",
+  outbound: "outbound"
+};
+var ChannelMessageSource = {
+  sms_record: "sms_record",
+  other_chat: "other_chat"
+};
+
+// src/types/generated/chat.ts
+var ChannelMessagesUnavailableReason = {
+  not_single_channel: "not_single_channel",
+  no_phone_number: "no_phone_number",
+  no_counterpart_phone: "no_counterpart_phone"
+};
+
+// src/types/generated/ehr_writeback.ts
+var EhrWritebackOutcomeResponseStatus = {
+  accepted: "accepted",
+  skipped: "skipped",
+  failed: "failed"
+};
+
 // src/types/chat-types.ts
 var SMS_DELIVERY_FAILURE_STATUSES = /* @__PURE__ */ new Set([
   "failed",
@@ -13215,6 +14148,46 @@ var PromoCodeStatus = {
   exhausted: "exhausted"
 };
 
+// src/types/generated/import_skipped_rule.ts
+var ImportReadinessIssueCode = {
+  phone_not_provisioned: "phone_not_provisioned",
+  phone_missing_default_workflow: "phone_missing_default_workflow",
+  inbox_missing_default_workflow: "inbox_missing_default_workflow",
+  workflow_missing_default_phone: "workflow_missing_default_phone"
+};
+var ImportReadinessIssueResourceType = {
+  phone: "phone",
+  inbox: "inbox",
+  workflow: "workflow"
+};
+var ImportSkippedRuleResourceGroupResourceType = {
+  phone: "phone",
+  inbox: "inbox",
+  member: "member"
+};
+var ImportSkippedRuleResponseNeededResourceTypesItem = {
+  phone: "phone",
+  inbox: "inbox",
+  member: "member"
+};
+var ImportSkippedRuleResponseParentKind = {
+  routine: "routine",
+  journey_step: "journey_step",
+  task: "task",
+  workflow: "workflow",
+  other: "other"
+};
+var ImportSkippedRuleResponseReasonCode = {
+  missing_binding: "missing_binding",
+  invalid_event_rule_cel: "invalid_event_rule_cel",
+  unresolved_journey_scope: "unresolved_journey_scope"
+};
+var ImportSkippedRuleResponseStatus = {
+  outstanding: "outstanding",
+  reconnected: "reconnected",
+  dismissed: "dismissed"
+};
+
 // src/features/registry.ts
 var FeatureCategory = /* @__PURE__ */ ((FeatureCategory2) => {
   FeatureCategory2["COMMUNICATION"] = "communication";
@@ -13340,6 +14313,12 @@ function isChatType(value) {
 
 // src/constants/models.ts
 var DEFAULT_CHAT_MODEL = "aws:bedrock:claude-4-5-haiku";
+var DEFAULT_AGENT_CHAT_MODEL = "openai:chat:gpt-5.6-luna";
+var DEFAULT_AGENT_REALTIME_MODEL = "xai:realtime:voice-agent-2";
+var DEFAULT_AGENT_REALTIME_MODEL_CONFIG = {
+  ttsModel: "native",
+  voiceModel: "xai:voice:cosmo"
+};
 var DEFAULT_VOICE_INFERENCE_MODEL = "openai:chat:gpt-5.6-luna";
 var DEFAULT_CUSTOM_VOICE_MODEL = "elevenlabs:voice:river";
 
@@ -13431,6 +14410,51 @@ function getAllResourceSlugs() {
   return Object.keys(RESOURCE_METADATA);
 }
 
+// src/types/generated/activity_feed.ts
+var ActivityGrain = {
+  month: "month",
+  week: "week",
+  day: "day",
+  hour: "hour",
+  event: "event"
+};
+var ActivityGroupBy = {
+  workspace: "workspace",
+  event_type: "event_type",
+  family: "family",
+  workspace_family: "workspace_family"
+};
+var ActivityOpenItemOrder = {
+  priority: "priority",
+  recency: "recency"
+};
+var ActivityWindowBasis = {
+  absolute: "absolute",
+  workspace_local: "workspace_local"
+};
+
+// src/types/generated/family.ts
+var ActivityEventFamily = {
+  people: "people",
+  conversations: "conversations",
+  journeys: "journeys",
+  automation: "automation",
+  operators: "operators",
+  administration: "administration"
+};
+var ActivityOutcome = {
+  ok: "ok",
+  attention: "attention",
+  failed: "failed"
+};
+
+// src/types/generated/entity_ref.ts
+var RefResolutionStatus = {
+  resolved: "resolved",
+  unresolved: "unresolved",
+  unsupported: "unsupported"
+};
+
 // src/scopes.ts
 var ScopeCategory = /* @__PURE__ */ ((ScopeCategory2) => {
   ScopeCategory2["WORKSPACE"] = "workspace";
@@ -13536,7 +14560,9 @@ var SCOPES = {
   "chats:write": {
     name: "chats:write",
     category: "chats" /* CHATS */,
-    description: "Send messages in conversations",
+    // Cross-member: acting in a conversation that is not yours. Sending in
+    // your own needs no scope (see the chats:read note on "all").
+    description: "Modify other members' conversations",
     implies: ["chats:read"]
   },
   "chats:admin": {
@@ -14235,6 +15261,8 @@ export {
   FhirVendor,
   FhirConnectionState,
   FhirClientType,
+  TestChatRunLane,
+  TestChatRunOutcome,
   CriterionType,
   DriverMode,
   AccessGrantResourceType,
@@ -14242,21 +15270,15 @@ export {
   AccessGrantStatus,
   AccessGrantTrigger,
   ConsentMethod,
+  MemberRelationshipKind,
+  RelatedMemberRole,
+  RelationshipCardinality,
+  MEMBER_RELATIONSHIP_KINDS,
   CONFIG_HEALTH_FACADE_CHECK_SLUGS,
   isConfigHealthFacadeCheckSlug,
-  ActivityActorKind,
-  ActivityAggregationKind,
-  ActivityCaptureState,
-  ActivityConfigAction,
-  ActivityConfigArea,
-  ActivityCoverageLimitation,
-  ActivityDirection,
-  ActivityEmptyReason,
-  ActivityEventType,
-  ActivityEventTypePreset,
-  ActivityGoalImpact,
-  ActivityTimelineProjection,
-  FormValueDisposition,
+  UiPromptPresentedKind,
+  UiPromptResponseKind,
+  UiPromptResponseStatus,
   parseExperimentStatCount,
   TERMINAL_TASK_STATES,
   WorkspaceInvitationsApi,
@@ -14265,13 +15287,14 @@ export {
   createApiModules,
   createWorkspaceClient,
   bindAccessGrantsMethods,
+  bindInterventionRequestsMethods,
   bindAgentTasksMethods,
   bindAgentsMethods,
   bindTasksMethods,
   bindChatsMethods,
   bindCallsMethods,
   bindDashboardsMethods,
-  bindActivityTimelineMethods,
+  bindActivityMethods,
   bindMotdMethods,
   bindTrackedLinksMethods,
   bindDataTypesMethods,
@@ -14311,6 +15334,10 @@ export {
   getVoiceModelId,
   canPreviewVoice,
   QUERY_VALUELESS_OPS,
+  ChannelMessageDirection,
+  ChannelMessageSource,
+  ChannelMessagesUnavailableReason,
+  EhrWritebackOutcomeResponseStatus,
   SMS_DELIVERY_FAILURE_STATUSES,
   isSMSDeliveryFailureStatus,
   AGENT_NOTE_ORIGINS,
@@ -14333,6 +15360,13 @@ export {
   WorkflowRoutingMode,
   WIDGET_SLUGS,
   PromoCodeStatus,
+  ImportReadinessIssueCode,
+  ImportReadinessIssueResourceType,
+  ImportSkippedRuleResourceGroupResourceType,
+  ImportSkippedRuleResponseNeededResourceTypesItem,
+  ImportSkippedRuleResponseParentKind,
+  ImportSkippedRuleResponseReasonCode,
+  ImportSkippedRuleResponseStatus,
   FeatureCategory,
   FeatureVisibility,
   initializeFeatures,
@@ -14354,14 +15388,24 @@ export {
   requiresAssistantParticipant,
   isChatType,
   DEFAULT_CHAT_MODEL,
+  DEFAULT_AGENT_CHAT_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL_CONFIG,
   DEFAULT_VOICE_INFERENCE_MODEL,
   DEFAULT_CUSTOM_VOICE_MODEL,
   getResourceMetadata,
   getAllResourceSlugs,
+  ActivityGrain,
+  ActivityGroupBy,
+  ActivityOpenItemOrder,
+  ActivityWindowBasis,
+  ActivityEventFamily,
+  ActivityOutcome,
+  RefResolutionStatus,
   ScopeCategory,
   SCOPES,
   ScopeManager,
   SCOPE_PRESETS,
   getRevisionState
 };
-//# sourceMappingURL=chunk-24L4RD4Z.js.map
+//# sourceMappingURL=chunk-N446FGCT.js.map