@gravity-rail/sdk 0.14.0 → 0.16.0

package/dist/index.cjs

@@ -110,6 +110,7 @@ __export(src_exports, {
   PIDS_SOURCES: () => PIDS_SOURCES,
   POSITIVE_RATING_THRESHOLD: () => POSITIVE_RATING_THRESHOLD,
   ProductType: () => ProductType,
+  PromoCodeStatus: () => PromoCodeStatus,
   QUERY_VALUELESS_OPS: () => QUERY_VALUELESS_OPS,
   QueriesApi: () => QueriesApi,
   REALTIME_MODEL_CUSTOM: () => REALTIME_MODEL_CUSTOM,
@@ -146,10 +147,12 @@ __export(src_exports, {
   TemplatesApi: () => TemplatesApi,
   ToolkitState: () => ToolkitState,
   WIDGET_SLUGS: () => WIDGET_SLUGS,
+  WORKFLOW_IMPLICIT_USE_SCOPE: () => WORKFLOW_IMPLICIT_USE_SCOPE,
   WorkflowAccessWarningResourceType: () => WorkflowAccessWarningResourceType,
   WorkflowBuilder: () => WorkflowBuilder,
   WorkflowResourceType: () => WorkflowAccessWarningResourceType,
   WorkspaceBuilder: () => WorkspaceBuilder,
+  WorkspaceBuilderResource: () => WorkspaceBuilderResource,
   WorkspaceFeature: () => WorkspaceFeature,
   WorkspaceProvisionStatus: () => WorkspaceProvisionStatus,
   areDependenciesSatisfied: () => areDependenciesSatisfied,
@@ -184,6 +187,9 @@ __export(src_exports, {
   isSMSDeliveryFailureStatus: () => isSMSDeliveryFailureStatus,
   parseOrgAuthChallenge: () => parseOrgAuthChallenge,
   requiresAssistantParticipant: () => requiresAssistantParticipant,
+  roleCanUseWorkflow: () => roleCanUseWorkflow,
+  roleImplicitWorkflowUseScope: () => roleImplicitWorkflowUseScope,
+  roleWorkflowAccess: () => roleWorkflowAccess,
   runWorkspaceScript: () => runWorkspaceScript,
   usesBuiltinAssistant: () => usesBuiltinAssistant,
   validateFeatureDependencies: () => validateFeatureDependencies
@@ -920,6 +926,18 @@ var AIModelsApi = class extends BaseApiClient {
     const url = queryString ? `ai-models/realtime?${queryString}` : "ai-models/realtime";
     return this.fetch(url);
   }
+  /**
+   * Get the voice presets offered by the simplified voice picker.
+   *
+   * A preset bundles a realtime speech-to-speech model with one of its native
+   * voices and the settings recommended alongside it, so choosing a voice is
+   * a single decision. Apply one by assigning its `config` wholesale; compare
+   * against it to tell a preset selection from a customised ("Custom") one.
+   * The full engine/voice/settings matrix lives on `getRealtimeModels`.
+   */
+  async getVoicePresets() {
+    return this.fetch("ai-models/voice-presets");
+  }
   /**
    * Get available voice models with metadata
    */
@@ -1954,6 +1972,8 @@ var ChatsApi = class extends BaseApiClient {
     if (options.mine !== void 0) params.append("mine", options.mine.toString());
     if (options.needsResponse !== void 0)
       params.append("needsResponse", options.needsResponse.toString());
+    if (options.needsResponseFirst !== void 0)
+      params.append("needsResponseFirst", options.needsResponseFirst.toString());
     if (options.paused !== void 0) params.append("paused", options.paused.toString());
     if (options.archived !== void 0) params.append("archived", options.archived.toString());
     if (options.channel) params.append("channel", options.channel);
@@ -2003,6 +2023,25 @@ var ChatsApi = class extends BaseApiClient {
   async getChat(wid, id) {
     return this.fetch(`w/${wid}/chats/${id}`);
   }
+  /**
+   * Create-chat preflight for SMS: is a conversation already live between this
+   * workspace number and this member?
+   *
+   * An SMS conversation with a member is a single stream — inbound SMS resolves
+   * to ONE current chat per (member phone, workspace phone) pair — so creating
+   * a new SMS chat SUPERSEDES the existing one and the member's next reply
+   * lands on the new chat. Callers use this to say so before committing.
+   *
+   * Read-only, `chats:read`, and PHI-safe by construction: status and timing
+   * only, no message content and no chat title.
+   */
+  async getCurrentSmsChat(wid, options) {
+    const params = new URLSearchParams({
+      memberId: options.memberId.toString(),
+      phoneNumberId: options.phoneNumberId.toString()
+    });
+    return this.fetch(`w/${wid}/chats/current-sms?${params}`);
+  }
   /** Get token usage statistics for a chat. */
   async getChatTokenUsage(wid, chatId) {
     return this.fetch(`w/${wid}/chats/${chatId}/token-usage`);
@@ -2028,6 +2067,10 @@ var ChatsApi = class extends BaseApiClient {
       `w/${wid}/chats/${chatId}/skills`
     );
   }
+  /** List built-in skills that can be selected before starting a Manager Chat. */
+  async getManagerSkills(wid) {
+    return this.fetch(`w/${wid}/chats/manager/skills`);
+  }
   /** List chat IDs that need a response. */
   async getChatsNeedsResponse(wid) {
     return this.fetch(`w/${wid}/chats/needs-response`);
@@ -3655,9 +3698,9 @@ var DocumoFaxApi = class extends BaseApiClient {
     params?.status?.forEach((value) => query.append("status", value));
     if (params?.receivedAfter) query.set("receivedAfter", params.receivedAfter);
     if (params?.receivedBefore) query.set("receivedBefore", params.receivedBefore);
-    const suffix = query.toString() === "" ? "" : `?${query.toString()}`;
+    const suffix2 = query.toString() === "" ? "" : `?${query.toString()}`;
     return this.fetch(
-      `w/${wid}/app-connections/documo-fax/faxes${suffix}`
+      `w/${wid}/app-connections/documo-fax/faxes${suffix2}`
     );
   }
   /**
@@ -5731,15 +5774,19 @@ var OrgApi = class extends BaseApiClient {
   async getA2PStatus(orgUuid) {
     return this.fetch(`o/${orgUuid}/phone-numbers/a2p/status`);
   }
+  /** Return fixed phone-number and outbound-messaging prices. */
+  async getPhoneBillingPricing(orgUuid) {
+    return this.fetch(`o/${orgUuid}/phone-numbers/pricing`);
+  }
   /**
    * Start A2P brand registration under a legal entity. `legalEntityUuid`
    * is required — brands register per legal entity (Customer Profile);
    * there is no primary-entity fallback.
    */
-  async startA2PRegistration(orgUuid, legalEntityUuid, brandName, brandDescription) {
+  async startA2PRegistration(orgUuid, legalEntityUuid, brandName, brandDescription, brandUuid = null) {
     return this.fetch(`o/${orgUuid}/phone-numbers/a2p/start`, {
       method: "POST",
-      body: JSON.stringify({ legalEntityUuid, brandName, brandDescription })
+      body: JSON.stringify({ legalEntityUuid, brandName, brandDescription, brandUuid })
     });
   }
   /**
@@ -5945,14 +5992,34 @@ var OrgApi = class extends BaseApiClient {
     );
   }
   /**
-   * The brand-addressable enrollment form URL (carries `?brand=…`). Outreach
-   * appends each patient's `external_id`. `url` is null until a Site is linked.
+   * The brand's enrollment-form template URL (carries `?brand=…`, no
+   * credential). `url` is null until a Site is linked. Do not append a
+   * patient identifier to this URL — use {@link mintA2PBrandEnrollmentLink}
+   * to get a patient-ready link instead.
    */
   async getA2PBrandEnrollmentUrl(orgUuid, brandUuid) {
     return this.fetch(
       `o/${orgUuid}/a2p-brands/${brandUuid}/enrollment-url`
     );
   }
+  /**
+   * Mint a patient-ready enrollment link for one patient.
+   *
+   * The returned URL carries a fresh, expiring, single-use `?grant=…` bound to
+   * the member that `externalId` resolves to. `externalId` (the patient's
+   * CRM/EHR identifier) travels in the request body, never the query string,
+   * so it stays out of access logs. When it matches no member, the
+   * credential-free template URL is returned rather than an error.
+   */
+  async mintA2PBrandEnrollmentLink(orgUuid, brandUuid, externalId) {
+    return this.fetch(
+      `o/${orgUuid}/a2p-brands/${brandUuid}/enrollment-url`,
+      {
+        method: "POST",
+        body: JSON.stringify({ externalId })
+      }
+    );
+  }
   /**
    * List available member roles for a workspace in the organization.
    */
@@ -7755,6 +7822,118 @@ var ToolkitsApi = class extends BaseApiClient {
   }
 };
 
+// src/api/tracked-links.ts
+function withFilters(params, options) {
+  if (options.dateFrom) params.append("dateFrom", options.dateFrom);
+  if (options.dateTo) params.append("dateTo", options.dateTo);
+  if (options.workflowId !== void 0) params.append("workflowId", String(options.workflowId));
+  return params;
+}
+function suffix(params) {
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+var TrackedLinksApi = class extends BaseApiClient {
+  /** Header counters plus whether shortening is configured and enabled. */
+  async getTrackedLinkSummary(wid, options = {}) {
+    const params = withFilters(new URLSearchParams(), options);
+    return this.fetch(
+      `w/${wid}/tracked-links/summary${suffix(params)}`
+    );
+  }
+  /**
+   * Known destination URLs, most recent first. Powers the "Clicked link"
+   * member-filter autocomplete, so it stays unaggregated and cheap.
+   */
+  async getTrackedLinkDestinations(wid, options = {}) {
+    const params = new URLSearchParams();
+    if (options.q) params.append("q", options.q);
+    if (options.limit !== void 0) params.append("limit", String(options.limit));
+    return this.fetch(
+      `w/${wid}/tracked-links/destinations${suffix(params)}`
+    );
+  }
+  /**
+   * Register a destination an author can reference as `{{links.<key>}}`.
+   *
+   * The URL is deduplicated server-side, so registering one the workspace
+   * already knows adopts that destination — including a row the retired
+   * auto-harvest left unnamed, whose click history then carries forward
+   * under the new key. Registering a URL that already has a *different* key
+   * is a 409: renaming is what `updateTrackedLinkDestination` is for.
+   *
+   * Keys use the same grammar as snippet keys: lowercase letters, digits,
+   * underscores and dots, starting with a letter (`intake_form`,
+   * `docs.privacy`). No hyphens — Jinja2 reads `links.spring-2026` as
+   * subtraction.
+   */
+  async createTrackedLinkDestination(wid, data) {
+    return this.fetch(`w/${wid}/tracked-links/destinations`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Re-key or relabel a destination.
+   *
+   * Changing `key` breaks templates: `{{links.old}}` stops resolving and the
+   * message ships without its link. Relabelling (`name`) is always safe.
+   * Passing `key: null` releases the handle so another destination can take
+   * it — the non-destructive alternative to deleting, which would take the
+   * click history with it. The URL is not editable.
+   */
+  async updateTrackedLinkDestination(wid, destinationId, data) {
+    return this.fetch(
+      `w/${wid}/tracked-links/destinations/${destinationId}`,
+      { method: "PUT", body: JSON.stringify(data) }
+    );
+  }
+  /** Per-destination sent / clicks / unique clickers / CTR for the window. */
+  async getTrackedLinkStats(wid, options = {}) {
+    const params = withFilters(new URLSearchParams(), options);
+    if (options.page !== void 0) params.append("page", String(options.page));
+    if (options.pageSize !== void 0) params.append("pageSize", String(options.pageSize));
+    if (options.q) params.append("q", options.q);
+    if (options.sortBy) params.append("sortBy", options.sortBy);
+    if (options.sortOrder) params.append("sortOrder", options.sortOrder);
+    return this.fetch(
+      `w/${wid}/tracked-links${suffix(params)}`
+    );
+  }
+  /** Clicks over time for the current filter selection. */
+  async getTrackedLinkTimeseries(wid, options = {}) {
+    const params = withFilters(new URLSearchParams(), options);
+    if (options.destinationId !== void 0) {
+      params.append("destinationId", String(options.destinationId));
+    }
+    if (options.granularity) params.append("granularity", options.granularity);
+    if (options.tz) params.append("tz", options.tz);
+    return this.fetch(
+      `w/${wid}/tracked-links/timeseries${suffix(params)}`
+    );
+  }
+  /**
+   * Delete one destination: its short links stop resolving and its recorded
+   * clicks are removed.
+   *
+   * Turning the workspace setting off only stops NEW links being minted —
+   * links already delivered to members keep working. This is the deliberate
+   * way to break them.
+   */
+  async deleteTrackedLinkDestination(wid, destinationId) {
+    return this.fetch(
+      `w/${wid}/tracked-links/destinations/${destinationId}`,
+      { method: "DELETE" }
+    );
+  }
+  /** Delete every destination, its links, and its clicks. Irreversible. */
+  async clearTrackedLinkDestinations(wid) {
+    return this.fetch(`w/${wid}/tracked-links/destinations`, {
+      method: "DELETE"
+    });
+  }
+};
+
 // src/api/journeys.ts
 var JourneysApi = class extends BaseApiClient {
   /**
@@ -8412,6 +8591,21 @@ function encodePermissions(permissions) {
   if (permissions.delete) accessMode |= PERMISSION_DELETE;
   return accessMode;
 }
+var WORKFLOW_IMPLICIT_USE_SCOPE = "workflows:admin";
+function roleImplicitWorkflowUseScope(role) {
+  return (role.grantedScopes ?? []).includes(WORKFLOW_IMPLICIT_USE_SCOPE) ? WORKFLOW_IMPLICIT_USE_SCOPE : null;
+}
+function roleWorkflowAccess(role, workflowId) {
+  const viaScope = roleImplicitWorkflowUseScope(role);
+  if (viaScope) {
+    return { accessMode: PERMISSION_USE | PERMISSION_EDIT, viaScope };
+  }
+  const entry = (role.workflowAccess ?? []).find((wa) => wa.workflowId === workflowId);
+  return { accessMode: entry?.accessMode ?? PERMISSION_NONE, viaScope: null };
+}
+function roleCanUseWorkflow(role, workflowId) {
+  return (roleWorkflowAccess(role, workflowId).accessMode & PERMISSION_USE) !== 0;
+}
 var Scope = /* @__PURE__ */ ((Scope2) => {
   Scope2["WORKSPACE_READ"] = "workspace:read";
   Scope2["WORKSPACE_WRITE"] = "workspace:write";
@@ -8565,11 +8759,13 @@ var EventRuleEventType = /* @__PURE__ */ ((EventRuleEventType2) => {
   EventRuleEventType2["DATA_RECORD_UPDATED"] = "data_record:updated";
   EventRuleEventType2["DATA_RECORD_CHANGED"] = "data_record:changed";
   EventRuleEventType2["CHAT_CREATED"] = "chat:created";
+  EventRuleEventType2["CHAT_SUMMARY"] = "chat:summary";
   EventRuleEventType2["CHAT_CALLBACK"] = "chat:callback";
   EventRuleEventType2["MEMBER_UPDATED"] = "member:updated";
   EventRuleEventType2["ROUTINE_TRIGGERED"] = "routine:triggered";
   EventRuleEventType2["ASSISTANT_MESSAGE"] = "workflow:assistant_message";
   EventRuleEventType2["USER_MESSAGE"] = "workflow:user_message";
+  EventRuleEventType2["WORKFLOW_EXECUTE"] = "workflow:execute";
   EventRuleEventType2["CALENDAR_EVENT_CREATED"] = "calendar_event:created";
   EventRuleEventType2["CALENDAR_EVENT_UPDATED"] = "calendar_event:updated";
   EventRuleEventType2["CALENDAR_EVENT_CANCELLED"] = "calendar_event:cancelled";
@@ -8639,7 +8835,6 @@ var WorkspaceFeature = /* @__PURE__ */ ((WorkspaceFeature2) => {
   WorkspaceFeature2["WEB_SEARCH"] = "web_search";
   WorkspaceFeature2["CALENDAR"] = "calendar";
   WorkspaceFeature2["EXPERIMENTS"] = "experiments";
-  WorkspaceFeature2["OPERATOR"] = "operator";
   WorkspaceFeature2["GMAIL"] = "gmail";
   WorkspaceFeature2["GCALENDAR"] = "gcalendar";
   WorkspaceFeature2["GDRIVE"] = "gdrive";
@@ -9330,6 +9525,20 @@ var WorkspacesApi = class extends BaseApiClient {
     if (featured !== void 0) params.set("featured", String(featured));
     return this.fetch(`products?${params.toString()}`);
   }
+  /**
+   * Check whether a promo code is usable, without redeeming it.
+   *
+   * Reserves nothing, so it is safe to call as a form field settles. Redemption
+   * happens server-side after checkout completes, when the organization and its
+   * subscription exist.
+   */
+  async previewPromoCode(code, options) {
+    return this.fetch("promo-codes/preview", {
+      method: "POST",
+      body: JSON.stringify({ code }),
+      signal: options?.signal
+    });
+  }
   /** Get a publicly accessible product by ID. */
   async getPublicProduct(id) {
     return this.fetch(`products/${id}`);
@@ -9549,6 +9758,7 @@ function createApiModules(apiKey, baseUrl, customFetch) {
     members: new MembersApi(apiKey, baseUrl, customFetch),
     milestones: new MilestonesApi(apiKey, baseUrl, customFetch),
     motd: new MotdApi(apiKey, baseUrl, customFetch),
+    trackedLinks: new TrackedLinksApi(apiKey, baseUrl, customFetch),
     confluence: new ConfluenceApi(apiKey, baseUrl, customFetch),
     mondayIntegration: new MondayIntegrationApi(apiKey, baseUrl, customFetch),
     notificationRules: new NotificationRulesApi(apiKey, baseUrl, customFetch),
@@ -9614,6 +9824,7 @@ var WORKSPACE_METHOD_NAMES = [
   "checkSiteSlugAvailability",
   "clearConnectionMemberExclusion",
   "clearMemberSwitch",
+  "clearTrackedLinkDestinations",
   "clickWorkspaceSupportRequestResource",
   "cloneDataType",
   "cloneTask",
@@ -9689,6 +9900,7 @@ var WORKSPACE_METHOD_NAMES = [
   "createSupervisor",
   "createTask",
   "createTeamsApp",
+  "createTrackedLinkDestination",
   "createWorkflow",
   "createWorkflowContributor",
   "createWorkflowFromTemplate",
@@ -9754,6 +9966,7 @@ var WORKSPACE_METHOD_NAMES = [
   "deleteSupervisor",
   "deleteTask",
   "deleteTeamsApp",
+  "deleteTrackedLinkDestination",
   "deleteWidgetDomain",
   "deleteWorkflow",
   "deleteWorkflowContributor",
@@ -9878,6 +10091,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getChatModelOverride",
   "getChatPhoneCalls",
   "getChatSkills",
+  "getManagerSkills",
   "getChatTodos",
   "getChatTokenUsage",
   "getChatToolCallMessages",
@@ -9893,6 +10107,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getConnectionSyncConfig",
   "getCredentialUpdateInvites",
   "getCurrentMember",
+  "getCurrentSmsChat",
   "getCustomToolkit",
   "getCustomToolkits",
   "getDashboard",
@@ -10057,6 +10272,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getPublicFolder",
   "getPublicFolderFiles",
   "getPublicProducts",
+  "previewPromoCode",
   "getQualification",
   "getQualifications",
   "getRecordingInfo",
@@ -10103,6 +10319,10 @@ var WORKSPACE_METHOD_NAMES = [
   "getTool",
   "getToolCallNames",
   "getToolkits",
+  "getTrackedLinkDestinations",
+  "getTrackedLinkStats",
+  "getTrackedLinkSummary",
+  "getTrackedLinkTimeseries",
   "getUnreadNotificationCount",
   "getUsageDashboard",
   "getVariableRegistry",
@@ -10337,6 +10557,7 @@ var WORKSPACE_METHOD_NAMES = [
   "updateTask",
   "updateTeamsApp",
   "updateThemeSettings",
+  "updateTrackedLinkDestination",
   "uploadFile",
   "updateVoicemailStatus",
   "updateWorkflow",
@@ -10428,11 +10649,13 @@ function bindTasksMethods(target, tasks, abilities) {
 function bindChatsMethods(target, chats) {
   target.getChats = chats.getChats.bind(chats);
   target.getChat = chats.getChat.bind(chats);
+  target.getCurrentSmsChat = chats.getCurrentSmsChat.bind(chats);
   target.getChatCallbacks = chats.getChatCallbacks.bind(chats);
   target.cancelChatCallback = chats.cancelChatCallback.bind(chats);
   target.getChatTokenUsage = chats.getChatTokenUsage.bind(chats);
   target.getChatTodos = chats.getChatTodos.bind(chats);
   target.getChatSkills = chats.getChatSkills.bind(chats);
+  target.getManagerSkills = chats.getManagerSkills.bind(chats);
   target.getChatsNeedsResponse = chats.getChatsNeedsResponse.bind(chats);
   target.getChatsDailyCreationStats = chats.getChatsDailyCreationStats.bind(chats);
   target.getToolCallNames = chats.getToolCallNames.bind(chats);
@@ -10506,6 +10729,18 @@ function bindMotdMethods(target, motd) {
   target.getMotd = motd.getMotd.bind(motd);
 }
 
+// src/client/bindings/tracked-links.ts
+function bindTrackedLinksMethods(target, trackedLinks) {
+  target.getTrackedLinkSummary = trackedLinks.getTrackedLinkSummary.bind(trackedLinks);
+  target.getTrackedLinkDestinations = trackedLinks.getTrackedLinkDestinations.bind(trackedLinks);
+  target.getTrackedLinkStats = trackedLinks.getTrackedLinkStats.bind(trackedLinks);
+  target.getTrackedLinkTimeseries = trackedLinks.getTrackedLinkTimeseries.bind(trackedLinks);
+  target.createTrackedLinkDestination = trackedLinks.createTrackedLinkDestination.bind(trackedLinks);
+  target.updateTrackedLinkDestination = trackedLinks.updateTrackedLinkDestination.bind(trackedLinks);
+  target.deleteTrackedLinkDestination = trackedLinks.deleteTrackedLinkDestination.bind(trackedLinks);
+  target.clearTrackedLinkDestinations = trackedLinks.clearTrackedLinkDestinations.bind(trackedLinks);
+}
+
 // src/client/bindings/data-types.ts
 function bindDataTypesMethods(target, dataTypes) {
   target.getDataTypes = dataTypes.getDataTypes.bind(dataTypes);
@@ -11001,6 +11236,7 @@ function bindToolkitsMethods(target, toolkits, templates, aiModels, customToolki
   target.getSTTModels = aiModels.getSTTModels.bind(aiModels);
   target.getTTSModels = aiModels.getTTSModels.bind(aiModels);
   target.getVoiceModels = aiModels.getVoiceModels.bind(aiModels);
+  target.getVoicePresets = aiModels.getVoicePresets.bind(aiModels);
   target.getAllModels = aiModels.getAllModels.bind(aiModels);
   target.getCustomToolkits = customToolkits.getCustomToolkits.bind(customToolkits);
   target.getCustomToolkit = customToolkits.getCustomToolkit.bind(customToolkits);
@@ -11466,11 +11702,13 @@ var GravityRailClient = class {
   // Chats API
   getChats;
   getChat;
+  getCurrentSmsChat;
   getChatCallbacks;
   cancelChatCallback;
   getChatTokenUsage;
   getChatTodos;
   getChatSkills;
+  getManagerSkills;
   getChatsNeedsResponse;
   getChatsDailyCreationStats;
   getToolCallNames;
@@ -11658,6 +11896,15 @@ var GravityRailClient = class {
   getDashboardWorkflowAssignmentStats;
   // MOTD API
   getMotd;
+  // Tracked Links analytics (#10934)
+  getTrackedLinkSummary;
+  getTrackedLinkDestinations;
+  getTrackedLinkStats;
+  getTrackedLinkTimeseries;
+  createTrackedLinkDestination;
+  updateTrackedLinkDestination;
+  deleteTrackedLinkDestination;
+  clearTrackedLinkDestinations;
   // Journeys API
   getJourneys;
   getJourney;
@@ -11762,6 +12009,7 @@ var GravityRailClient = class {
   getProduct;
   getWorkspaceProduct;
   getPublicProducts;
+  previewPromoCode;
   getPublicProduct;
   createProduct;
   updateProduct;
@@ -12116,6 +12364,7 @@ var GravityRailClient = class {
   getSTTModels;
   getTTSModels;
   getVoiceModels;
+  getVoicePresets;
   getAllModels;
   getCustomToolkits;
   getCustomToolkit;
@@ -12446,6 +12695,7 @@ var GravityRailClient = class {
     bindQueriesMethods(this, apis.queries);
     bindDashboardsMethods(this, apis.dashboards);
     bindMotdMethods(this, apis.motd);
+    bindTrackedLinksMethods(this, apis.trackedLinks);
     bindJourneysMethods(this, apis.journeys);
     bindExperimentsMethods(this, apis.experiments);
     bindOperatorMethods(this, apis.operatorGroups);
@@ -12638,6 +12888,14 @@ var WorkspaceBuilderResource = class {
     }
     return this._uuid;
   }
+  /**
+   * True for resources the server creates on our behalf (currently a
+   * journey's `Start` step). They are kept in the resource list so edges can
+   * reference them, but they are never created, printed, or counted.
+   */
+  get isImplicit() {
+    return false;
+  }
   matchKey() {
     return void 0;
   }
@@ -12660,6 +12918,19 @@ function resolveRefValue(value) {
   }
   return out;
 }
+function resolveIdRefs(value) {
+  return resolveIdRefValue(value);
+}
+function resolveIdRefValue(value) {
+  if (value instanceof WorkspaceBuilderResource) return value.id;
+  if (Array.isArray(value)) return value.map(resolveIdRefValue);
+  if (!isPlainRecord(value)) return value;
+  const out = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    out[key] = resolveIdRefValue(nestedValue);
+  }
+  return out;
+}
 
 // src/workspace-builder/automation.ts
 var MemberFilterBuilder = class extends WorkspaceBuilderResource {
@@ -12673,7 +12944,12 @@ var MemberFilterBuilder = class extends WorkspaceBuilderResource {
   description;
   /** Query-engine predicate (JSON IR) authored on MemberFilter.query. */
   query = null;
-  /** Set the filter's query-engine predicate (JSON IR). */
+  /**
+   * Set the filter's query-engine predicate (JSON IR).
+   *
+   * Anywhere the IR wants a numeric id you may pass the builder that will own
+   * it (e.g. a label in a `member.labelId` value); refs resolve at apply time.
+   */
   setQuery(query) {
     this.query = query;
     return this;
@@ -12682,10 +12958,12 @@ var MemberFilterBuilder = class extends WorkspaceBuilderResource {
     return `MemberFilter: ${this.name}${this.query ? " (query)" : ""}`;
   }
   async apply(client) {
+    if (this._existed) return;
     const payload = {
       name: this.name,
       description: this.description,
-      query: this.query
+      // Builder refs inside the IR become ids here; see resolveIdRefs.
+      query: resolveIdRefs(this.query)
     };
     const result = await client.createMemberFilter(payload);
     this._id = result.id;
@@ -12980,35 +13258,134 @@ var MemberLabelBuilder = class extends WorkspaceBuilderResource {
 };
 
 // src/workspace-builder/journeys.ts
+var SECONDS_PER_DAY = 86400;
+function edgeKey(parentId, childId) {
+  return `${parentId}:${childId}`;
+}
+function edgeCondition(options) {
+  const clauses = [];
+  if (options.afterDays !== void 0) {
+    clauses.push(`days_since(parent_step.completed_at) >= ${options.afterDays}`);
+  }
+  if (options.when) clauses.push(`(${options.when})`);
+  if (!clauses.length) return void 0;
+  return clauses.join(" && ");
+}
 var JourneyStepBuilder = class extends WorkspaceBuilderResource {
   // journey-decoupling Phase 7: a Journey step no longer links to a Workflow.
   // A step nudges via EventRule actions instead of running a Workflow, so the
   // builder no longer accepts or emits a workflow reference.
-  constructor(name, journey, order = 0, description = "") {
+  constructor(name, journey, order = 0, description = "", options = {}) {
     super();
     this.name = name;
     this.journey = journey;
     this.order = order;
     this.description = description;
+    this.assigneeId = options.assigneeId;
+    this.posX = options.posX;
+    this.posY = options.posY;
   }
   name;
   journey;
   order;
   description;
   connections = [];
-  connectsTo(child, condition, required = false, timeoutSeconds) {
-    this.connections.push({ parent: this, child, condition, required, timeoutSeconds });
+  rules = [];
+  assigneeId;
+  posX;
+  posY;
+  /** Wire an edge to `child` and return the CHILD, so chains read linearly. */
+  connectsTo(child, options = {}) {
+    if (child === this) {
+      throw new Error(`Journey step '${this.name}' cannot connect to itself`);
+    }
+    const abandonSeconds = options.abandonAfterDays !== void 0 ? options.abandonAfterDays * SECONDS_PER_DAY : options.timeoutSeconds;
+    this.connections.push({
+      parent: this,
+      child,
+      condition: edgeCondition(options),
+      required: options.required ?? false,
+      timeoutSeconds: abandonSeconds,
+      order: options.order,
+      filterId: options.filterId
+    });
+    return child;
+  }
+  /**
+   * Attach a `JOURNEY_STEP_EXECUTE` action — what this step actually DOES
+   * when a member reaches it. A step with no rules is inert: the member
+   * lands on it, nothing is sent, and the journey moves on.
+   */
+  onExecute(actionType, params = {}, options = {}) {
+    this.rules.push({
+      uuid: crypto.randomUUID(),
+      actionType,
+      actionParams: params,
+      options
+    });
     return this;
   }
+  /**
+   * Text the member. `phoneNumberUUID` is a workspace PhoneNumber with SMS
+   * enabled. Pass `workflowUUID` to start an SMS workflow chat, or
+   * `messageTemplate` for a one-off send.
+   */
+  sendsSms(params, options = {}) {
+    return this.onExecute("sms:send" /* SMS_SEND */, params, options);
+  }
+  /**
+   * Call the member. Both the workspace PhoneNumber uuid (voice enabled) and
+   * the Workflow uuid that drives the call are required.
+   */
+  callsMember(params, options = {}) {
+    return this.onExecute("phone:call" /* PHONE_CALL */, params, options);
+  }
+  /** Email the member from a workspace inbox. */
+  sendsEmail(params, options = {}) {
+    return this.onExecute("email:send" /* EMAIL_SEND */, params, options);
+  }
+  /** Label the member on arrival — pass label builders, not ids. */
+  addsLabels(labels, options = {}) {
+    return this.onExecute(
+      "member:label" /* MEMBER_LABEL_ACTION */,
+      { addLabelIds: labels },
+      options
+    );
+  }
+  /** True once this step has something to do when a member reaches it. */
+  get hasOutreach() {
+    return this.rules.length > 0;
+  }
+  eventRuleInputs() {
+    return this.rules.map((rule) => ({
+      uuid: rule.uuid,
+      eventType: "journey_step:execute" /* JOURNEY_STEP_EXECUTE */,
+      actionType: rule.actionType,
+      actionParams: resolveRefs(rule.actionParams),
+      ...rule.options.name ? { name: rule.options.name } : {},
+      ...rule.options.when ? { conditions: rule.options.when } : {},
+      ...rule.options.delaySeconds ? { delay: rule.options.delaySeconds } : {},
+      active: rule.options.active ?? true
+    }));
+  }
   planLine() {
-    return `Step: ${this.name}`;
+    const actions = this.rules.map((rule) => rule.actionType).join(" + ");
+    return `Step: ${this.name}${actions ? ` (${actions})` : ""}`;
   }
   async apply(client) {
+    if (this._existed) return;
     if (this.journey._id === void 0) return;
+    const rules = this.eventRuleInputs();
     const payload = {
       name: this.name,
       description: this.description,
-      order: this.order
+      order: this.order,
+      ...this.assigneeId !== void 0 ? { assigneeId: this.assigneeId } : {},
+      ...this.posX !== void 0 ? { posX: this.posX } : {},
+      ...this.posY !== void 0 ? { posY: this.posY } : {},
+      // Saved atomically with the step, so a partial failure cannot leave
+      // an inert step behind.
+      ...rules.length ? { eventRules: rules } : {}
     };
     const result = await client.createStep(this.journey._id, payload);
     this._id = result.id;
@@ -13016,26 +13393,59 @@ var JourneyStepBuilder = class extends WorkspaceBuilderResource {
     this._created = true;
   }
 };
+var StartStepBuilder = class extends JourneyStepBuilder {
+  get isImplicit() {
+    return true;
+  }
+  planLine() {
+    return "Step: Start (auto-created)";
+  }
+  async apply() {
+  }
+};
 var JourneyBuilder = class extends WorkspaceBuilderResource {
   constructor(name, options = {}) {
     super();
     this.name = name;
     this.description = options.description ?? "";
+    this.start = new StartStepBuilder("Start", this, 0);
+    this.steps.push(this.start);
   }
   name;
   description;
   steps = [];
   goals = [];
+  /** The auto-created `Start` step — connect the first real step to it. */
+  start;
+  /** `parentId:childId` for every edge the server already has (see `adopt`). */
+  existingEdges = /* @__PURE__ */ new Set();
   step(name, options = {}) {
     const step = new JourneyStepBuilder(
       name,
       this,
-      options.order ?? 0,
-      options.description ?? ""
+      options.order ?? this.steps.length,
+      options.description ?? "",
+      options
     );
     this.steps.push(step);
     return step;
   }
+  /**
+   * Declare a linear cadence: `Start → steps[0] → steps[1] → …`, each edge
+   * carrying the matching entry from `spacing`.
+   *
+   * Chaining is not optional polish. A step created with no incoming edge is
+   * a ROOT, and every root fires the moment a member enrols — a "three
+   * follow-ups over four days" journey built without edges sends all three
+   * at once.
+   */
+  sequence(steps, spacing = []) {
+    let parent = this.start;
+    steps.forEach((step, index) => {
+      parent = parent.connectsTo(step, spacing[index] ?? {});
+    });
+    return this;
+  }
   goal(name, options = {}) {
     this.goals.push({
       name,
@@ -13043,17 +13453,85 @@ var JourneyBuilder = class extends WorkspaceBuilderResource {
       step: options.step,
       completionCel: options.completionCel ?? options.completion_cel,
       value: options.value,
-      order: options.order ?? 0
+      order: options.order ?? this.goals.length
     });
     return this;
   }
+  /**
+   * Authoring problems that make a journey silently misbehave at runtime.
+   * Reported at plan/preview time, before anything is written.
+   */
+  validate() {
+    const problems = [];
+    const withParents = /* @__PURE__ */ new Set();
+    for (const step of this.steps) {
+      for (const connection of step.connections) withParents.add(connection.child);
+    }
+    for (const step of this.steps) {
+      if (step === this.start) continue;
+      if (!withParents.has(step)) {
+        problems.push(
+          `step '${step.name}' has no incoming edge \u2014 it is a root and fires for every member the moment they enrol. Connect it from journey.start or a prior step.`
+        );
+      }
+      if (!step.hasOutreach) {
+        problems.push(
+          `step '${step.name}' has no JOURNEY_STEP_EXECUTE action \u2014 a member reaching it gets nothing. Add one with .sendsSms / .callsMember / .sendsEmail / .onExecute.`
+        );
+      }
+    }
+    if (!this.goals.length) {
+      problems.push(`journey '${this.name}' has no goals \u2014 nothing measures whether it works.`);
+    }
+    return problems;
+  }
+  /**
+   * Adopt an existing journey, its steps, and its EDGES, matched by name.
+   *
+   * Re-running a builder script is normal — a program is usually built in
+   * stages as provisioning lands — and without adoption the second run would
+   * create a duplicate journey and a duplicate set of steps beside the live
+   * one, with members enrolled in neither.
+   *
+   * The edge set is recorded from the server's own `childConnections` rather
+   * than inferred from "both steps exist". A first run that created the steps
+   * and then failed before writing an edge leaves exactly that state, and
+   * inferring would skip the missing edge on every subsequent run — leaving a
+   * permanent root step that fires for every member at enrolment, silently.
+   * The journey detail read eager-loads connections, so the real answer is
+   * already in hand; there is no reason to guess.
+   */
+  adopt(existing) {
+    super.adopt(existing);
+    const existingSteps = existing.steps ?? [];
+    const byName = new Map(existingSteps.map((step) => [step.name, step]));
+    const startStep = existingSteps.find((step) => step.id === existing.startStepId) ?? byName.get("Start");
+    if (startStep) this.start.adopt(startStep);
+    for (const step of this.steps) {
+      if (step === this.start) continue;
+      const match = byName.get(step.name);
+      if (match) step.adopt(match);
+    }
+    for (const step of existingSteps) {
+      for (const edge of step.childConnections ?? []) {
+        this.existingEdges.add(edgeKey(edge.parentStepId, edge.childStepId));
+      }
+    }
+  }
+  /** True when the server already has this exact edge. */
+  hasEdge(parent, child) {
+    if (parent._id === void 0 || child._id === void 0) return false;
+    return this.existingEdges.has(edgeKey(parent._id, child._id));
+  }
   planLine() {
     const parts = [];
-    if (this.steps.length) parts.push(`${this.steps.length} steps`);
+    const real = this.steps.filter((step) => step !== this.start);
+    if (real.length) parts.push(`${real.length} steps`);
     if (this.goals.length) parts.push(`${this.goals.length} goals`);
     return `Journey: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
   }
   async apply(client) {
+    if (this._existed) return;
     const result = await client.createJourney({
       name: this.name,
       description: this.description
@@ -13061,6 +13539,15 @@ var JourneyBuilder = class extends WorkspaceBuilderResource {
     this._id = result.id;
     this._uuid = result.uuid;
     this._created = true;
+    const startStep = (result.steps ?? []).find(
+      (step) => step.id === result.startStepId || step.name === "Start"
+    );
+    if (!startStep) {
+      throw new Error(
+        `Journey '${this.name}' was created without a Start step; edges from journey.start cannot be wired.`
+      );
+    }
+    this.start.adopt(startStep);
   }
 };
 function buildJourneyConnectionPayload(connection) {
@@ -13070,7 +13557,9 @@ function buildJourneyConnectionPayload(connection) {
     childStepUuid: connection.child._uuid,
     ...connection.condition ? { celCondition: connection.condition } : {},
     ...connection.required ? { required: true } : {},
-    ...connection.timeoutSeconds ? { timeoutSeconds: connection.timeoutSeconds } : {}
+    ...connection.timeoutSeconds ? { timeoutSeconds: connection.timeoutSeconds } : {},
+    ...connection.order !== void 0 ? { order: connection.order } : {},
+    ...connection.filterId !== void 0 ? { filterId: connection.filterId } : {}
   };
 }
 function buildJourneyGoalPayload(goal) {
@@ -13356,6 +13845,15 @@ var PHASES = /* @__PURE__ */ new Map([
   [JourneyBuilder, 7],
   [JourneyStepBuilder, 8]
 ]);
+function phaseFor(resource) {
+  let ctor = resource.constructor;
+  while (ctor) {
+    const phase = PHASES.get(ctor);
+    if (phase !== void 0) return phase;
+    ctor = Object.getPrototypeOf(ctor);
+  }
+  return 99;
+}
 var WorkspaceBuilder = class {
   constructor(client) {
     this.client = client;
@@ -13418,7 +13916,8 @@ var WorkspaceBuilder = class {
 ${"=".repeat(50)}`);
     writeLine("Plan");
     writeLine("=".repeat(50));
-    for (const resource of resources) {
+    const declared = resources.filter((resource) => !resource.isImplicit);
+    for (const resource of declared) {
       writeLine(`  + ${resource.planLine()}`);
     }
     const wiring = this.collectWiringSummary(resources);
@@ -13426,8 +13925,9 @@ ${"=".repeat(50)}`);
       writeLine("\n  Wiring:");
       for (const line of wiring) writeLine(`    ${line}`);
     }
+    this.reportJourneyWarnings();
     writeLine(`
-  Total: ${resources.length} resources, ${wiring.length} connections`);
+  Total: ${declared.length} resources, ${wiring.length} connections`);
     writeLine(`${"=".repeat(50)}
 `);
   }
@@ -13438,7 +13938,8 @@ ${"=".repeat(50)}`);
 ${"=".repeat(50)}`);
     writeLine("Preview");
     writeLine("=".repeat(50));
-    for (const resource of resources) {
+    const declared = resources.filter((resource) => !resource.isImplicit);
+    for (const resource of declared) {
       if (resource._existed) {
         writeLine(`  = ${resource.planLine()} (exists, id=${resource._id})`);
       } else {
@@ -13450,8 +13951,9 @@ ${"=".repeat(50)}`);
       writeLine("\n  Wiring:");
       for (const line of wiring) writeLine(`    ${line}`);
     }
-    const toCreate = resources.filter((resource) => !resource._existed);
-    const existing = resources.filter((resource) => resource._existed);
+    this.reportJourneyWarnings();
+    const toCreate = declared.filter((resource) => !resource._existed);
+    const existing = declared.filter((resource) => resource._existed);
     writeLine(
       `
   Total: ${toCreate.length} to create, ${existing.length} existing, ${wiring.length} connections`
@@ -13459,6 +13961,18 @@ ${"=".repeat(50)}`);
     writeLine(`${"=".repeat(50)}
 `);
   }
+  /**
+   * Print journey authoring problems that only bite at runtime — a step with
+   * no incoming edge fires for every member at enrolment, and a step with no
+   * action does nothing at all. Both look fine in the editor, so they are
+   * surfaced before the write rather than discovered from a member's phone.
+   */
+  reportJourneyWarnings() {
+    const problems = this.resources.filter((resource) => resource instanceof JourneyBuilder).flatMap((journey) => journey.validate());
+    if (!problems.length) return;
+    writeLine("\n  Journey warnings:");
+    for (const problem of problems) writeLine(`    ! ${problem}`);
+  }
   async apply() {
     const resources = this.sortedResources();
     await this.resolveExisting(resources);
@@ -13466,6 +13980,7 @@ ${"=".repeat(50)}`);
     writeLine("Applying...");
     for (const resource of resources) {
       try {
+        if (resource.isImplicit) continue;
         if (resource._existed) {
           const key = resourceKey(resource);
           summary[key] ??= [];
@@ -13523,6 +14038,29 @@ Done! Created ${count} resources.`);
         }
       }
     }
+    const filterNames = new Map(
+      resources.filter(
+        (resource) => resource instanceof MemberFilterBuilder
+      ).map((resource) => [resource.name, resource])
+    );
+    if (filterNames.size) {
+      for (const existing of await this.client.getMemberFilters()) {
+        if (existing.name && filterNames.has(existing.name)) {
+          filterNames.get(existing.name).adopt(existing);
+        }
+      }
+    }
+    const journeyNames = new Map(
+      resources.filter((resource) => resource instanceof JourneyBuilder).map((resource) => [resource.name, resource])
+    );
+    if (journeyNames.size) {
+      const existingJourneys = await this.client.getJourneys();
+      for (const existing of existingJourneys.items) {
+        if (!existing.name || !journeyNames.has(existing.name)) continue;
+        const detail = await this.client.getJourney(existing.id);
+        journeyNames.get(existing.name).adopt(detail);
+      }
+    }
     if (!workflowNames.size) return;
     const existingWorkflows = await this.client.getWorkflows();
     for (const { workflow: existing } of existingWorkflows.items) {
@@ -13573,9 +14111,7 @@ Done! Created ${count} resources.`);
         all.push(...resource.steps);
       }
     }
-    return all.sort(
-      (a, b) => (PHASES.get(a.constructor) ?? 99) - (PHASES.get(b.constructor) ?? 99)
-    );
+    return all.sort((a, b) => phaseFor(a) - phaseFor(b));
   }
   collectWiringSummary(resources) {
     const lines = [];
@@ -13596,7 +14132,11 @@ Done! Created ${count} resources.`);
           lines.push(`${rule.actionType} rule on '${resource.name}'`);
       } else if (resource instanceof JourneyStepBuilder) {
         for (const connection of resource.connections) {
-          lines.push(`${connection.parent.name} -> ${connection.child.name}`);
+          const guard = connection.condition ? ` [${connection.condition}]` : "";
+          lines.push(`${connection.parent.name} -> ${connection.child.name}${guard}`);
+        }
+        for (const rule of resource.rules) {
+          lines.push(`${rule.actionType} on step '${resource.name}'`);
         }
       } else if (resource instanceof JourneyBuilder) {
         for (const goal of resource.goals) lines.push(`Goal: ${goal.name}`);
@@ -13712,6 +14252,10 @@ Done! Created ${count} resources.`);
       if (!(resource instanceof JourneyStepBuilder)) continue;
       for (const connection of resource.connections) {
         if (resource.journey._id === void 0) continue;
+        if (resource.journey.hasEdge(connection.parent, connection.child)) {
+          writeLine(`  Exists: ${connection.parent.name} -> ${connection.child.name}`);
+          continue;
+        }
         const payload = buildJourneyConnectionPayload(connection);
         if (!payload) continue;
         await this.client.createConnection(resource.journey._id, payload);
@@ -13722,6 +14266,12 @@ Done! Created ${count} resources.`);
   async applyJourneyGoals(resources) {
     for (const resource of resources) {
       if (!(resource instanceof JourneyBuilder) || resource._id === void 0) continue;
+      if (resource._existed) {
+        for (const goal of resource.goals) {
+          writeLine(`  Skipped (journey already exists): Goal: ${goal.name}`);
+        }
+        continue;
+      }
       for (const goal of resource.goals) {
         await this.client.createGoal(resource._id, buildJourneyGoalPayload(goal));
         writeLine(`  Created goal: ${goal.name}`);
@@ -14148,6 +14698,15 @@ var WorkflowAccessWarningResourceType = {
 // src/types/widget-domain-types.ts
 var WIDGET_SLUGS = ["chat", "operator", "operator-tools", "chat-app"];
 
+// src/types/generated/promo_code_service.ts
+var PromoCodeStatus = {
+  active: "active",
+  scheduled: "scheduled",
+  expired: "expired",
+  inactive: "inactive",
+  exhausted: "exhausted"
+};
+
 // src/features/registry.ts
 var FeatureCategory = /* @__PURE__ */ ((FeatureCategory2) => {
   FeatureCategory2["COMMUNICATION"] = "communication";
@@ -15160,6 +15719,7 @@ function getRevisionState(workflow, revision) {
   PIDS_SOURCES,
   POSITIVE_RATING_THRESHOLD,
   ProductType,
+  PromoCodeStatus,
   QUERY_VALUELESS_OPS,
   QueriesApi,
   REALTIME_MODEL_CUSTOM,
@@ -15196,10 +15756,12 @@ function getRevisionState(workflow, revision) {
   TemplatesApi,
   ToolkitState,
   WIDGET_SLUGS,
+  WORKFLOW_IMPLICIT_USE_SCOPE,
   WorkflowAccessWarningResourceType,
   WorkflowBuilder,
   WorkflowResourceType,
   WorkspaceBuilder,
+  WorkspaceBuilderResource,
   WorkspaceFeature,
   WorkspaceProvisionStatus,
   areDependenciesSatisfied,
@@ -15234,6 +15796,9 @@ function getRevisionState(workflow, revision) {
   isSMSDeliveryFailureStatus,
   parseOrgAuthChallenge,
   requiresAssistantParticipant,
+  roleCanUseWorkflow,
+  roleImplicitWorkflowUseScope,
+  roleWorkflowAccess,
   runWorkspaceScript,
   usesBuiltinAssistant,
   validateFeatureDependencies