@gravity-rail/sdk 0.15.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,
@@ -151,6 +152,7 @@ __export(src_exports, {
   WorkflowBuilder: () => WorkflowBuilder,
   WorkflowResourceType: () => WorkflowAccessWarningResourceType,
   WorkspaceBuilder: () => WorkspaceBuilder,
+  WorkspaceBuilderResource: () => WorkspaceBuilderResource,
   WorkspaceFeature: () => WorkspaceFeature,
   WorkspaceProvisionStatus: () => WorkspaceProvisionStatus,
   areDependenciesSatisfied: () => areDependenciesSatisfied,
@@ -924,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
    */
@@ -2053,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`);
@@ -3680,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}`
     );
   }
   /**
@@ -5756,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 })
     });
   }
   /**
@@ -5970,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.
    */
@@ -7780,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 {
   /**
@@ -8605,6 +8759,7 @@ 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";
@@ -9370,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}`);
@@ -9589,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),
@@ -9654,6 +9824,7 @@ var WORKSPACE_METHOD_NAMES = [
   "checkSiteSlugAvailability",
   "clearConnectionMemberExclusion",
   "clearMemberSwitch",
+  "clearTrackedLinkDestinations",
   "clickWorkspaceSupportRequestResource",
   "cloneDataType",
   "cloneTask",
@@ -9729,6 +9900,7 @@ var WORKSPACE_METHOD_NAMES = [
   "createSupervisor",
   "createTask",
   "createTeamsApp",
+  "createTrackedLinkDestination",
   "createWorkflow",
   "createWorkflowContributor",
   "createWorkflowFromTemplate",
@@ -9794,6 +9966,7 @@ var WORKSPACE_METHOD_NAMES = [
   "deleteSupervisor",
   "deleteTask",
   "deleteTeamsApp",
+  "deleteTrackedLinkDestination",
   "deleteWidgetDomain",
   "deleteWorkflow",
   "deleteWorkflowContributor",
@@ -9918,6 +10091,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getChatModelOverride",
   "getChatPhoneCalls",
   "getChatSkills",
+  "getManagerSkills",
   "getChatTodos",
   "getChatTokenUsage",
   "getChatToolCallMessages",
@@ -10098,6 +10272,7 @@ var WORKSPACE_METHOD_NAMES = [
   "getPublicFolder",
   "getPublicFolderFiles",
   "getPublicProducts",
+  "previewPromoCode",
   "getQualification",
   "getQualifications",
   "getRecordingInfo",
@@ -10144,6 +10319,10 @@ var WORKSPACE_METHOD_NAMES = [
   "getTool",
   "getToolCallNames",
   "getToolkits",
+  "getTrackedLinkDestinations",
+  "getTrackedLinkStats",
+  "getTrackedLinkSummary",
+  "getTrackedLinkTimeseries",
   "getUnreadNotificationCount",
   "getUsageDashboard",
   "getVariableRegistry",
@@ -10378,6 +10557,7 @@ var WORKSPACE_METHOD_NAMES = [
   "updateTask",
   "updateTeamsApp",
   "updateThemeSettings",
+  "updateTrackedLinkDestination",
   "uploadFile",
   "updateVoicemailStatus",
   "updateWorkflow",
@@ -10475,6 +10655,7 @@ function bindChatsMethods(target, 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);
@@ -10548,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);
@@ -11043,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);
@@ -11514,6 +11708,7 @@ var GravityRailClient = class {
   getChatTokenUsage;
   getChatTodos;
   getChatSkills;
+  getManagerSkills;
   getChatsNeedsResponse;
   getChatsDailyCreationStats;
   getToolCallNames;
@@ -11701,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;
@@ -11805,6 +12009,7 @@ var GravityRailClient = class {
   getProduct;
   getWorkspaceProduct;
   getPublicProducts;
+  previewPromoCode;
   getPublicProduct;
   createProduct;
   updateProduct;
@@ -12159,6 +12364,7 @@ var GravityRailClient = class {
   getSTTModels;
   getTTSModels;
   getVoiceModels;
+  getVoicePresets;
   getAllModels;
   getCustomToolkits;
   getCustomToolkit;
@@ -12489,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);
@@ -12681,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;
   }
@@ -12703,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 {
@@ -12716,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;
@@ -12725,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;
@@ -13023,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;
@@ -13059,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,
@@ -13086,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
@@ -13104,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) {
@@ -13113,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) {
@@ -13399,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;
@@ -13461,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);
@@ -13469,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)}
 `);
   }
@@ -13481,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 {
@@ -13493,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`
@@ -13502,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);
@@ -13509,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] ??= [];
@@ -13566,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) {
@@ -13616,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 = [];
@@ -13639,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}`);
@@ -13755,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);
@@ -13765,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}`);
@@ -14191,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";
@@ -15203,6 +15719,7 @@ function getRevisionState(workflow, revision) {
   PIDS_SOURCES,
   POSITIVE_RATING_THRESHOLD,
   ProductType,
+  PromoCodeStatus,
   QUERY_VALUELESS_OPS,
   QueriesApi,
   REALTIME_MODEL_CUSTOM,
@@ -15244,6 +15761,7 @@ function getRevisionState(workflow, revision) {
   WorkflowBuilder,
   WorkflowResourceType,
   WorkspaceBuilder,
+  WorkspaceBuilderResource,
   WorkspaceFeature,
   WorkspaceProvisionStatus,
   areDependenciesSatisfied,