@gravity-rail/sdk 0.22.0 → 0.33.0

package/dist/index.js

@@ -7,6 +7,12 @@ import {
   AccessGrantStatus,
   AccessGrantTrigger,
   AccessLevel,
+  ActivityEventFamily,
+  ActivityGrain,
+  ActivityGroupBy,
+  ActivityOpenItemOrder,
+  ActivityOutcome,
+  ActivityWindowBasis,
   AppsApi,
   BUILTIN_ASSISTANT_CHAT_TYPES,
   BuildersApi,
@@ -16,13 +22,22 @@ import {
   CELApi,
   CHAT_TYPES,
   CapabilityClass,
+  ChannelMessageDirection,
+  ChannelMessageSource,
+  ChannelMessagesUnavailableReason,
+  ChatMuteReason,
   ConsentMethod,
   CriterionType,
+  DEFAULT_AGENT_CHAT_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL_CONFIG,
   DEFAULT_CHAT_MODEL,
   DEFAULT_CUSTOM_VOICE_MODEL,
   DEFAULT_THINKING_SPEECH_PHRASES,
   DEFAULT_VOICE_INFERENCE_MODEL,
+  DigestSlotRole,
   DriverMode,
+  EhrWritebackOutcomeResponseStatus,
   EmailDnsRecordType,
   EventRuleActionType,
   EventRuleEventType,
@@ -33,15 +48,22 @@ import {
   FhirConnectionState,
   FhirVendor,
   GravityRailClient,
+  ImportSkippedRuleResourceGroupResourceType,
+  ImportSkippedRuleResponseNeededResourceTypesItem,
+  ImportSkippedRuleResponseParentKind,
+  ImportSkippedRuleResponseReasonCode,
+  ImportSkippedRuleResponseStatus,
   InboundFaxStatus,
   InvitationStatus,
   JobPosition,
   MASKED_SECRET_SENTINEL,
+  MEMBER_RELATIONSHIP_KINDS,
   McpServerState,
   MemberFeature,
   MemberImportMatchInfoMatchType,
   MemberImportPreviewRowAction,
   MemberImportValidationError,
+  MemberRelationshipKind,
   MemberType,
   MenuItemResponseItemType,
   MergeMemberRolesRequestAccessStrategy,
@@ -75,8 +97,11 @@ import {
   REALTIME_MODEL_OPENAI,
   REALTIME_MODEL_OPENAI_2,
   REALTIME_MODEL_OPENAI_MINI,
+  RefResolutionStatus,
   Region,
   RegistrationIdentifier,
+  RelatedMemberRole,
+  RelationshipCardinality,
   Resource,
   SCOPES,
   SCOPE_PRESETS,
@@ -98,7 +123,12 @@ import {
   TTS_MODEL_ELEVENLABS_TURBO,
   TTS_PREVIEW_PROVIDERS,
   TemplatesApi,
+  TestChatRunLane,
+  TestChatRunOutcome,
   ToolkitState,
+  UiPromptPresentedKind,
+  UiPromptResponseKind,
+  UiPromptResponseStatus,
   WIDGET_SLUGS,
   WORKFLOW_IMPLICIT_USE_SCOPE,
   WorkflowAccessWarningResourceType,
@@ -142,7 +172,7 @@ import {
   roleWorkflowAccess,
   usesBuiltinAssistant,
   validateFeatureDependencies
-} from "./chunk-WMA6YCAS.js";
+} from "./chunk-WDYHAQDY.js";
 import {
   AttendeeResponseStatus,
   AttendeeStatus,
@@ -157,13 +187,14 @@ import {
   DataSensitivity,
   DataTypeRecordScope,
   IndexStatus
-} from "./chunk-3HAV5XUJ.js";
+} from "./chunk-HRUMZ46V.js";
 import {
   ApiError,
   BaseApiClient,
+  ChatInteractionController,
   getCookieValue,
   parseOrgAuthChallenge
-} from "./chunk-7OLBLLV7.js";
+} from "./chunk-P2E6LU7I.js";
 
 // src/workspace-builder/resource.ts
 function isRecord(value) {
@@ -208,6 +239,19 @@ var WorkspaceBuilderResource = class {
   get isImplicit() {
     return false;
   }
+  /**
+   * True when `apply()` is safe — and required — to run against a resource
+   * that was ADOPTED rather than created.
+   *
+   * False by default because most builders create only: re-running their
+   * `apply()` on an existing resource would make a duplicate. Override it
+   * when `apply()` is an idempotent full write keyed on stable identities,
+   * which is the only way a re-run can express an EDIT (a removed goal, a
+   * reordered timeline) rather than just an addition.
+   */
+  get appliesWhenExisting() {
+    return false;
+  }
   matchKey() {
     return void 0;
   }
@@ -886,6 +930,755 @@ function buildJourneyGoalPayload(goal) {
     ...goal.value !== void 0 ? { value: goal.value } : {}
   };
 }
+var V2RouteBuilder = class {
+  constructor(name, options = {}) {
+    this.name = name;
+    this.options = options;
+  }
+  name;
+  options;
+  touches = [];
+  /**
+   * The DECISION RULE uuid. Adopted for the same reason an Ending's is:
+   * `MemberJourneyStep.entry_decision_rule_id` points at this row with
+   * `ON DELETE SET NULL`, so recreating it on a re-run would erase which arm
+   * every already-routed enrollment is on — invisibly, since both rules
+   * "exist" afterwards.
+   */
+  _ruleUuid;
+  /** Append a touch to this arm. Order is call order. */
+  touch(name, options = {}) {
+    const touch = new V2TouchBuilder(name, options);
+    this.touches.push(touch);
+    return touch;
+  }
+};
+var V2BranchBuilder = class {
+  routes = [];
+  /** Append a route. Declaration order is evaluation order. */
+  route(name, options = {}) {
+    const route = new V2RouteBuilder(name, options);
+    this.routes.push(route);
+    return route;
+  }
+};
+var V2TouchBuilder = class {
+  /**
+   * The name is CANONICALIZED here, once, and everything downstream reads it:
+   * the `key:<name>` address, the payload, adoption's name lookup, and the
+   * uniqueness gate. The API trims it before storing
+   * (`JourneyV2TouchInput`/`JourneyV2EndingInput` name validators), so a
+   * builder holding `" Welcome "` would send an address for a name the server
+   * does not have, fail to find its own step on the way back, and treat it as
+   * new on the next run — archiving the live step and its history. One
+   * representation at the boundary is the only way that cannot happen; a
+   * second trim anywhere downstream would be a place for the two to drift.
+   */
+  constructor(name, options = {}) {
+    this.options = options;
+    this.name = name.trim();
+  }
+  options;
+  rules = [];
+  /** Filled in from the server's response so a re-run keeps this touch. */
+  _uuid;
+  /**
+   * The exclusive branch that follows this touch, when it has one. A touch
+   * carrying a branch gets NO ordinary outgoing connection: its routes are
+   * the only way out, so touches declared after it are reached only by an arm
+   * naming them in `continueAt`.
+   */
+  _branch;
+  name;
+  /**
+   * Attach an exclusive branch after this touch, or return the existing one.
+   *
+   * Idempotent so a script can add routes in stages without accidentally
+   * declaring two branches on one touch — which the server has no shape for,
+   * since a touch owns exactly one ordered route set.
+   */
+  branch() {
+    this._branch ??= new V2BranchBuilder();
+    return this._branch;
+  }
+  /**
+   * The request-local address this step answers to (plan §3.8 / phase 6).
+   *
+   * A saved step is addressed by its uuid; an unsaved one by a `key` derived
+   * from its authored name. Deriving from the NAME rather than minting a
+   * uuid4 keeps the payload stable across re-runs of the same script — a
+   * fresh random key on every run would make the request differ from itself
+   * for no reason, and the server's EventRule sync matches on the uuids the
+   * payload carries. Names are already asserted unique within a journey,
+   * which is what makes a name-derived key unique.
+   *
+   * {@link V2EndingBuilder} INHERITS this rather than deriving its own: an
+   * Ending's anchor key and a touch's key land in one server-side namespace
+   * (`stepKey` is one field), so two derivations that drifted would produce
+   * two spellings of the same address and a goal would 404 on the one its
+   * step was not sent under.
+   *
+   * Two steps of one name therefore answer to one address. {@link preflight}
+   * is the first enforcement point and refuses it before any write, counting
+   * touches and Endings together and comparing names trimmed, as the API
+   * stores them. Without that gate the collision surfaces twice and both
+   * times too late: the server rejects the definition PUT after `apply()` has
+   * created the Journey, and {@link indexStoredByName} rejects the SECOND run
+   * of a script whose two stored steps make `adopt()` a coin flip.
+   */
+  get _address() {
+    return this._uuid ?? `key:${this.name}`;
+  }
+  /**
+   * Re-attach the EventRule uuids the server already stores for this touch.
+   *
+   * Identity is the operator-set rule NAME. `.sendsSms(...)` does not require
+   * one, so an unnamed rule falls back to its actionType — but ONLY when that
+   * answer is 1:1: exactly one unnamed draft of that actionType here, and
+   * exactly one stored rule of it left unclaimed there. Anything else throws.
+   *
+   * The ordinal-within-actionType fallback this replaces was not a weaker
+   * identity, it was the wrong one. Inserting a new unnamed rule ABOVE an
+   * existing same-type rule shifts every position by one, so the new rule
+   * adopted the existing rule's uuid — taking over its delivery bookkeeping —
+   * and the existing rule was written as brand new and archived. Nothing in
+   * the payload showed it: both rules "exist" afterwards. When the script
+   * cannot say which rule is which, the honest answer is to ask the author to
+   * name them, not to guess by position.
+   */
+  adoptRuleUuids(serverRules) {
+    const namedDrafts = this.rules.filter((draft) => !!draft.options.name);
+    const storedByName = indexStoredByName(
+      serverRules,
+      new Set(namedDrafts.map((draft) => draft.options.name)),
+      `touch '${this.name}'`,
+      "action"
+    );
+    const claimed = /* @__PURE__ */ new Set();
+    for (const draft of namedDrafts) {
+      const match = storedByName.get(draft.options.name);
+      if (!match) continue;
+      draft.adoptedUuid = match.uuid;
+      claimed.add(match);
+    }
+    const unnamedByActionType = /* @__PURE__ */ new Map();
+    for (const draft of this.rules) {
+      if (draft.options.name) continue;
+      const actionType = String(draft.actionType);
+      unnamedByActionType.set(actionType, [
+        ...unnamedByActionType.get(actionType) ?? [],
+        draft
+      ]);
+    }
+    for (const [actionType, drafts] of unnamedByActionType) {
+      const candidates = serverRules.filter(
+        (rule) => String(rule.actionType) === actionType && !claimed.has(rule)
+      );
+      if (!candidates.length) continue;
+      if (drafts.length === 1 && candidates.length === 1) {
+        drafts[0].adoptedUuid = candidates[0].uuid;
+        continue;
+      }
+      throw new Error(
+        `touch '${this.name}' has ${drafts.length} unnamed ${actionType} action(s) and the server has ${candidates.length} \u2014 so there is no way to tell which stored action each one is. Adopting by position swaps their identities the moment an action is inserted or removed, which moves one action's delivery history onto another. Give these actions names (\`{ name: ... }\`) so each one can be matched to the right rule.`
+      );
+    }
+  }
+  /** Attach a `JOURNEY_STEP_EXECUTE` action. Same contract as legacy. */
+  onExecute(actionType, params = {}, options = {}) {
+    this.rules.push({
+      uuid: crypto.randomUUID(),
+      actionType,
+      actionParams: params,
+      options
+    });
+    return this;
+  }
+  sendsSms(params, options = {}) {
+    return this.onExecute("sms:send" /* SMS_SEND */, params, options);
+  }
+  callsMember(params, options = {}) {
+    return this.onExecute("phone:call" /* PHONE_CALL */, params, options);
+  }
+  sendsEmail(params, options = {}) {
+    return this.onExecute("email:send" /* EMAIL_SEND */, params, options);
+  }
+  get hasOutreach() {
+    return this.rules.length > 0;
+  }
+  eventRuleInputs() {
+    return this.rules.map((rule) => ({
+      uuid: rule.adoptedUuid ?? 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
+    }));
+  }
+};
+var V2EndingBuilder = class extends V2TouchBuilder {
+  constructor(name, when, filterId) {
+    super(name);
+    this.when = when;
+    this.filterId = filterId;
+  }
+  when;
+  filterId;
+  /**
+   * The DECISION RULE uuid, distinct from `_uuid` (the anchor step's).
+   *
+   * An Ending is two rows: a `JourneyDecisionRule` carrying the condition and
+   * precedence, and a `JourneyStep` anchor carrying its actions, goals, and
+   * status history. Adopting only the anchor left the rule to be recreated on
+   * every re-run — and `MemberJourney.latched_ending_rule_id` /
+   * `JourneyStatusLog.journey_decision_rule_id` point at the RULE with
+   * `ON DELETE SET NULL`, so every completed enrollment silently forgot which
+   * Ending it took.
+   */
+  _ruleUuid;
+  /**
+   * An Ending cannot carry a branch, and saying so is the whole override.
+   *
+   * `V2EndingBuilder extends V2TouchBuilder` for the identity and addressing
+   * an Ending's anchor shares with a touch, which also inherits every touch
+   * method — `branch()` among them. Inherited unchanged it would set
+   * `_branch` on an object nothing ever reads it from: the Ending serializer
+   * writes `{uuid|key, name, celCondition, filterId, eventRules}` and no
+   * `branch`, and `allTouches()` walks only the timeline, so the routes are
+   * never numbered, validated, adopted or sent. The author gets no error and
+   * a definition quietly missing what they asked for.
+   *
+   * An Ending is terminal by construction — it is the rule that ENDS an
+   * enrollment — so there is no shape to serialize even if the payload had a
+   * field for it. Refusing at the call is the only point where the author is
+   * still holding the mistake.
+   *
+   * @see foreignAnchorProblem for why this names no Ending.
+   */
+  branch() {
+    throw new Error(
+      "an Ending cannot carry a branch. An Ending terminates an enrollment, so there is nothing after it to route to, and the atomic definition has no field to send one under \u2014 the routes would be silently dropped. Put the branch on the touch that leads to this Ending instead, and give each arm its own Ending."
+    );
+  }
+};
+var JourneyV2Builder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+    this.activate = options.activate ?? false;
+  }
+  name;
+  description;
+  touches = [];
+  endings = [];
+  goals = [];
+  /** Activate after the definition is written and validated. */
+  activate;
+  /** Optimistic-concurrency token, from create or adoption. */
+  _expectedUpdatedAt;
+  /** Server status at adoption — decides whether a re-run must pause first. */
+  _status;
+  /**
+   * A v2 definition write is idempotent, so an ADOPTED journey is written
+   * too. That is the whole point of adopting one: the PUT is a full,
+   * uuid-keyed replacement, so re-running a script is how an author expresses
+   * an edit. The legacy builder stays create-only — its `apply()` only knows
+   * how to create, and re-running it would duplicate.
+   */
+  get appliesWhenExisting() {
+    return true;
+  }
+  /** Append a touch to the timeline. Order is call order. */
+  touch(name, options = {}) {
+    const touch = new V2TouchBuilder(name, options);
+    this.touches.push(touch);
+    return touch;
+  }
+  /**
+   * Every touch in the timeline, arms included, depth first.
+   *
+   * Identity adoption, name-uniqueness and validation all have to see arm
+   * touches — a walk over the top level alone would leave every arm touch
+   * recreated on each re-run, silently archiving its member history.
+   */
+  allTouches() {
+    const out = [];
+    const walk = (touches) => {
+      for (const touch of touches) {
+        out.push(touch);
+        for (const route of touch._branch?.routes ?? []) walk(route.touches);
+      }
+    };
+    walk(this.touches);
+    return out;
+  }
+  /** Every route in the timeline, at every nesting depth, depth first. */
+  allRoutes() {
+    const out = [];
+    for (const touch of this.allTouches()) {
+      for (const route of touch._branch?.routes ?? []) out.push(route);
+    }
+    return out;
+  }
+  /** Append an Ending. Call order is evaluation order. */
+  ending(name, options) {
+    const ending = new V2EndingBuilder(name, options.when, options.filterId);
+    this.endings.push(ending);
+    return ending;
+  }
+  goal(name, options = {}) {
+    this.goals.push({
+      name,
+      description: options.description,
+      step: options.step,
+      completionCel: options.completionCel,
+      value: options.value
+    });
+    return this;
+  }
+  /**
+   * Authoring problems the server's publish validator would reject.
+   *
+   * A different rule set from the legacy builder's on purpose. "No incoming
+   * edge" has no meaning in a timeline — position is the order — and the v2
+   * failure modes are different ones: an action-less touch that is not an
+   * explicit wait, and an Ending with no condition.
+   */
+  validate() {
+    const problems = [];
+    if (!this.touches.length) {
+      problems.push(
+        `journey '${this.name}' has no touches \u2014 an empty timeline has nothing to execute.`
+      );
+    }
+    const armHeads = new Set(
+      this.allRoutes().map((route) => route.touches[0]).filter(Boolean)
+    );
+    this.allTouches().forEach((touch) => {
+      if (touch.hasOutreach) return;
+      const wait = touch.options.wait;
+      const isFirst = this.touches[0] === touch;
+      const isExplicitWait = !isFirst && !armHeads.has(touch) && (wait?.afterDays !== void 0 || !!wait?.when || wait?.filterId !== void 0);
+      if (isExplicitWait) return;
+      problems.push(
+        `touch '${touch.name}' has no JOURNEY_STEP_EXECUTE action \u2014 a member reaching it gets nothing. Add one, or give it a wait so it is an explicit grace period.`
+      );
+    });
+    for (const touch of this.allTouches()) {
+      const branch = touch._branch;
+      if (!branch) continue;
+      const fallbacks = branch.routes.filter(
+        (route) => !route.options.when?.trim() && route.options.filterId === void 0
+      );
+      if (branch.routes.length - fallbacks.length < 1) {
+        problems.push(
+          `branch after touch '${touch.name}' needs at least one conditional route \u2014 one declared with a \`when\`, a \`filterId\`, or both. Members wait at the branch until a route matches, so an Otherwise is optional.`
+        );
+      }
+      if (fallbacks.length > 1) {
+        problems.push(
+          `branch after touch '${touch.name}' declares ${fallbacks.length} Otherwise routes; a branch has at most one unconditional fallback.`
+        );
+      }
+      if (fallbacks.length === 1 && branch.routes[branch.routes.length - 1] !== fallbacks[0]) {
+        problems.push(
+          `the Otherwise route of the branch after touch '${touch.name}' is not last; it is taken immediately, so any route after it can never be reached.`
+        );
+      }
+      for (const route of branch.routes) {
+        if (!route.touches.length && !route.options.continueAt) {
+          problems.push(
+            `route '${route.name}' has no target \u2014 give it at least one touch, or a \`continueAt\` naming the touch it continues to.`
+          );
+        }
+      }
+    }
+    for (const ending of this.endings) {
+      if (!ending.when?.trim() && ending.filterId === void 0) {
+        problems.push(
+          `ending '${ending.name}' has no condition \u2014 an Ending that always matches terminates every enrolment on evaluation order alone. Give it a \`when\` expression, a \`filterId\`, or both.`
+        );
+      }
+    }
+    return problems;
+  }
+  /**
+   * Shapes this definition cannot express, found BEFORE anything is written.
+   *
+   * A different list from {@link validate}, and a different consequence:
+   * those are warnings the orchestrator prints and then writes anyway, these
+   * are refusals. For each one the payload has no way to say what the script
+   * asked for, so serializing past it would write a DIFFERENT program from
+   * the one the script wrote, with nothing afterwards to say so.
+   *
+   * It has to run before the first write rather than during serialization,
+   * because {@link apply} creates the Journey — or pauses a live one — before
+   * it builds the payload. A refusal raised from `definitionPayload()` has
+   * therefore already left an empty journey shell behind, or taken a
+   * production program off the air.
+   *
+   * PURE: reads only what the script declared, never what the server holds,
+   * so it is correct at any point — before adoption included — and
+   * `WorkspaceBuilder.preflight()` can stay a synchronous, side-effect-free
+   * check a caller may run directly. Nothing here needs adoption to have run:
+   * an anchor the server has not seen is addressed by its request-local key,
+   * so "has this Ending been saved" is no longer a question a refusal
+   * depends on.
+   */
+  preflight() {
+    const problems = [];
+    this.allTouches().forEach((touch, index) => {
+      const wait = touch.options.wait;
+      if (wait?.afterDays !== void 0 && wait.when) {
+        problems.push(waitExclusivityProblem(index));
+      }
+    });
+    const owned = this.ownedAnchors();
+    this.goals.forEach((goal, index) => {
+      const step = goal.step;
+      if (step && !owned.has(step)) {
+        problems.push(foreignAnchorProblem(index, anchorKind(step)));
+      }
+    });
+    const stepNames = [
+      ...this.allTouches().map((touch) => touch.name),
+      ...this.endings.map((ending) => ending.name)
+    ];
+    const claims = /* @__PURE__ */ new Map();
+    for (const name of stepNames) claims.set(name, (claims.get(name) ?? 0) + 1);
+    const repeated = [...claims.values()].filter((count) => count > 1).length;
+    if (repeated) problems.push(sharedStepNameProblem(repeated));
+    const nameless = stepNames.filter((name) => !name).length;
+    if (nameless) problems.push(namelessStepProblem(nameless));
+    return problems;
+  }
+  /**
+   * Every step a goal in THIS journey can anchor to, compared by object
+   * identity — touches AND Endings, which is why the element type names both
+   * rather than leaning on `V2EndingBuilder extends V2TouchBuilder` to smuggle
+   * Endings in under a touch-only annotation.
+   *
+   * A goal anchored to some other journey's builder is not a near miss the
+   * server can catch: an unsaved one sends a `stepKey` this definition never
+   * declares (a 404 whose cause is invisible), and a SAVED one sends a real
+   * `stepUuid` belonging to a live step somewhere else.
+   */
+  ownedAnchors() {
+    return /* @__PURE__ */ new Set([...this.allTouches(), ...this.endings]);
+  }
+  planLine() {
+    const parts = [];
+    const touchCount = this.allTouches().length;
+    const routeCount = this.allRoutes().length;
+    if (touchCount) parts.push(`${touchCount} touches`);
+    if (routeCount) parts.push(`${routeCount} routes`);
+    if (this.endings.length) parts.push(`${this.endings.length} endings`);
+    if (this.goals.length) parts.push(`${this.goals.length} goals`);
+    return `Journey (v2): ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  /**
+   * Re-attach every stable child identity the server already holds.
+   *
+   * The atomic endpoint is a FULL REPLACEMENT keyed on uuids: an omitted
+   * uuid does not mean "unchanged", it means "create a new one and archive
+   * whatever the old one was". So anything this misses is silently recreated
+   * on every re-run of the same script — and a script is normally re-run,
+   * because a program is built in stages. Each identity has a different thing
+   * hanging off it, and losing it costs something specific:
+   *
+   * | identity | what re-creating it destroys |
+   * |---|---|
+   * | touch step uuid | the touch's `MemberJourneyStep` history |
+   * | EventRule uuid | that action's delivery bookkeeping |
+   * | Ending RULE uuid | which Ending completed enrollments latched |
+   * | Ending anchor uuid | the Ending's status history and goal anchor |
+   * | goal uuid | every member's satisfaction row for that goal |
+   *
+   * `existing` is the journey DETAIL or AUTHORING projection. Both carry
+   * `steps[].eventRules`, `goals`, and `decisionRules` —
+   * the read projection redacts CEL, not identity — so one fetch is enough
+   * and no second round trip is needed. (The orchestrator asks for the
+   * authoring projection anyway: this builder holds `journeys:write` because
+   * it is about to PUT, and the superset costs nothing.)
+   *
+   * Names are the only key available on a FIRST adoption, and a duplicate
+   * name makes adoption a coin flip between two live resources. That throws
+   * rather than guessing: silently attaching a touch to the wrong step
+   * archives real member history.
+   */
+  adopt(existing) {
+    super.adopt(existing);
+    this._expectedUpdatedAt = existing.updatedAt;
+    this._status = existing.status;
+    this.assertUnambiguousNames();
+    this.adoptChildIdentities(existing);
+  }
+  /** Reject a script whose own names cannot identify a resource. */
+  assertUnambiguousNames() {
+    assertUniqueNames(
+      this.allTouches().map((touch) => touch.name),
+      `journey '${this.name}'`,
+      "touch"
+    );
+    assertUniqueNames(
+      this.allRoutes().map((route) => route.name),
+      `journey '${this.name}'`,
+      "route"
+    );
+    assertUniqueNames(
+      this.endings.map((ending) => ending.name),
+      `journey '${this.name}'`,
+      "ending"
+    );
+    assertUniqueNames(
+      this.goals.map((goal) => goal.name),
+      `journey '${this.name}'`,
+      "goal"
+    );
+    for (const touch of [...this.allTouches(), ...this.endings]) {
+      const names = touch.rules.map((rule) => rule.options.name).filter(Boolean);
+      assertUniqueNames(names, `touch '${touch.name}'`, "action name");
+    }
+  }
+  adoptChildIdentities(payload) {
+    const steps = payload.steps ?? [];
+    const referencedStepNames = /* @__PURE__ */ new Set([
+      ...this.allTouches().map((touch) => touch.name),
+      ...this.endings.map((ending) => ending.name)
+    ]);
+    const stepsByName = indexStoredByName(
+      steps,
+      referencedStepNames,
+      `journey '${this.name}'`,
+      "step"
+    );
+    const stepsById = new Map(steps.map((step) => [step.id, step]));
+    for (const touch of this.allTouches()) {
+      const match = stepsByName.get(touch.name);
+      if (!match) continue;
+      touch._uuid = match.uuid;
+      touch.adoptRuleUuids(match.eventRules ?? []);
+    }
+    const routeRules = (payload.decisionRules ?? []).filter(
+      (rule) => rule.sourceStepId !== null && rule.sourceStepId !== void 0
+    );
+    const declaredRoutes = this.allRoutes();
+    const routesByName = indexStoredByName(
+      routeRules,
+      new Set(declaredRoutes.map((route) => route.name)),
+      `journey '${this.name}'`,
+      "route"
+    );
+    for (const route of declaredRoutes) {
+      const stored = routesByName.get(route.name);
+      if (stored) route._ruleUuid = stored.uuid;
+    }
+    const endingRules = (payload.decisionRules ?? []).filter(
+      (rule) => rule.sourceStepId === null || rule.sourceStepId === void 0
+    );
+    const rulesByName = indexStoredByName(
+      endingRules,
+      new Set(this.endings.map((ending) => ending.name)),
+      `journey '${this.name}'`,
+      "ending"
+    );
+    for (const ending of this.endings) {
+      const rule = rulesByName.get(ending.name);
+      const anchor = rule ? stepsById.get(rule.targetStepId) : stepsByName.get(ending.name);
+      if (rule) ending._ruleUuid = rule.uuid;
+      if (!anchor) continue;
+      ending._uuid = anchor.uuid;
+      ending.adoptRuleUuids(anchor.eventRules ?? []);
+    }
+    const goalsByName = indexStoredByName(
+      payload.goals ?? [],
+      new Set(this.goals.map((goal) => goal.name)),
+      `journey '${this.name}'`,
+      "goal"
+    );
+    for (const goal of this.goals) {
+      const match = goalsByName.get(goal.name);
+      if (match) goal._uuid = match.uuid;
+    }
+  }
+  /** The atomic request body. Exposed so a test can assert it without HTTP. */
+  definitionPayload() {
+    const owned = this.ownedAnchors();
+    const positions = new Map(
+      this.allTouches().map((touch, index) => [touch, index])
+    );
+    return {
+      expectedUpdatedAt: this._expectedUpdatedAt ?? "",
+      touches: this.touches.map((touch) => serializeV2Touch(touch, positions)),
+      endings: this.endings.map((ending) => ({
+        ...ending._ruleUuid ? { uuid: ending._ruleUuid } : {},
+        // Anchor address, exactly as `serializeV2Touch` sends a touch's:
+        // the saved anchor's uuid, or the request-local `key` a goal in
+        // this same save names it by. Both come from `_address`, so the
+        // Ending and the goal cannot be sent under two spellings.
+        ...ending._uuid ? { anchorUuid: ending._uuid } : { key: ending._address },
+        name: ending.name,
+        // The two predicates are sent INDEPENDENTLY (rule-filters plan
+        // §3.2). A filter-only Ending carries no `celCondition` at all
+        // rather than an empty one the server would have to normalize.
+        ...ending.when ? { celCondition: ending.when } : {},
+        ...ending.filterId !== void 0 ? { filterId: ending.filterId } : {},
+        eventRules: ending.eventRuleInputs()
+      })),
+      // ALWAYS sent, `[]` included. The field distinguishes omitted (leave
+      // goals alone) from empty (delete them), and this builder owns the
+      // goal list — so omitting an empty list would make goal REMOVAL the
+      // one edit a script cannot express: delete the `.goal(...)` call, re-run,
+      // and the goal stays live forever.
+      goals: this.goals.map((goal, index) => ({
+        ...goal._uuid ? { uuid: goal._uuid } : {},
+        name: goal.name,
+        ...goal.description ? { description: goal.description } : {},
+        ...serializeV2GoalAnchor(goal.step, index, owned),
+        ...goal.completionCel ? { completionCel: goal.completionCel } : {},
+        ...goal.value !== void 0 ? { value: goal.value } : {}
+      }))
+    };
+  }
+  async apply(client) {
+    const problems = this.preflight();
+    if (problems.length) {
+      throw new Error(
+        `Journey (v2) has ${problems.length} problem(s) and was not applied:
+` + problems.map((problem) => `  - ${problem}`).join("\n")
+      );
+    }
+    if (!this._existed) {
+      const created = await client.createJourney({
+        name: this.name,
+        description: this.description,
+        // Explicit, always. An omitted executionModel means `legacy` on the
+        // server, so a v2 builder that forgot it would quietly author a
+        // legacy Journey that happens to look like a timeline.
+        executionModel: "v2"
+      });
+      this._id = created.id;
+      this._uuid = created.uuid;
+      this._created = true;
+      this._expectedUpdatedAt = created.updatedAt;
+    } else if (this._status === "active" && this.activate) {
+      const paused = await client.updateJourney(this.id, { status: "paused" });
+      this._expectedUpdatedAt = paused.updatedAt;
+    }
+    const saved = await client.putJourneyV2Definition(this.id, this.definitionPayload());
+    this._expectedUpdatedAt = saved.updatedAt;
+    this.adoptWrittenUuids(saved);
+    if (this.activate) {
+      await client.updateJourney(this.id, { status: "active" });
+    }
+  }
+  /**
+   * Re-attach the uuids the server assigned, so a follow-up write matches.
+   *
+   * The PUT returns the AUTHORING projection, which is the same shape
+   * `adopt` reads — so this is the same operation against a payload we just
+   * caused, and it uses the same code path rather than a second, thinner
+   * copy that would drift.
+   */
+  adoptWrittenUuids(saved) {
+    this.adoptChildIdentities(saved);
+  }
+};
+function indexStoredByName(rows, referenced, owner, kind) {
+  const byName = /* @__PURE__ */ new Map();
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const name = row.name;
+    if (typeof name !== "string" || !name) continue;
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+    if (!byName.has(name)) byName.set(name, row);
+  }
+  for (const [name, count] of counts) {
+    if (count < 2 || !referenced.has(name)) continue;
+    throw new Error(
+      `${owner} already has ${count} ${kind}s named '${name}'. This script adopts by name, so it cannot tell which ${kind} it owns \u2014 and the one it does not pick is archived on the next save, taking its history with it. Rename them so each name identifies one ${kind}.`
+    );
+  }
+  return byName;
+}
+function assertUniqueNames(names, owner, kind) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name)) {
+      throw new Error(
+        `${owner} has two ${kind}s named '${name}'. The v2 builder adopts an existing journey by name, so duplicates would attach a builder to either one at random \u2014 archiving the other's history on the next save. Rename one.`
+      );
+    }
+    seen.add(name);
+  }
+}
+function serializeV2Touch(touch, positions) {
+  return {
+    ...touch._uuid ? { uuid: touch._uuid } : { key: touch._address },
+    name: touch.name,
+    ...touch.options.description ? { description: touch.options.description } : {},
+    ...touch.options.wait ? { wait: buildV2Wait(touch.options.wait, positions.get(touch)) } : {},
+    eventRules: touch.eventRuleInputs(),
+    ...touch._branch ? {
+      branch: {
+        routes: touch._branch.routes.map((route) => ({
+          ...route._ruleUuid ? { uuid: route._ruleUuid } : {},
+          name: route.name,
+          // Omitted, not null, and INDEPENDENT of each other: a route
+          // with neither predicate IS the Otherwise marker, one with
+          // either is conditional, and one with both is ANDed
+          // (rule-filters plan §3.2). The server normalizes "" to the
+          // same thing as omitted.
+          ...route.options.when ? { celCondition: route.options.when } : {},
+          ...route.options.filterId !== void 0 ? { filterId: route.options.filterId } : {},
+          touches: route.touches.map((armTouch) => serializeV2Touch(armTouch, positions)),
+          ...route.options.continueAt ? { continueAt: route.options.continueAt._address } : {}
+        }))
+      }
+    } : {}
+  };
+}
+function serializeV2GoalAnchor(step, goalIndex, owned) {
+  if (!step) return {};
+  if (!owned.has(step)) throw new Error(foreignAnchorProblem(goalIndex, anchorKind(step)));
+  if (step._uuid) return { stepUuid: step._uuid };
+  return { stepKey: step._address };
+}
+function foreignAnchorProblem(goalIndex, kind) {
+  return `goal at index ${goalIndex} is anchored to ${kind === "Ending" ? "an" : "a"} ${kind} that belongs to a different journey builder. A goal anchor is part of the same atomic definition as its step, so it can only name a touch or Ending this journey declares.`;
+}
+function waitExclusivityProblem(touchIndex) {
+  const where = touchIndex === void 0 ? "this touch" : `touch at index ${touchIndex}`;
+  return `${where} sets both afterDays and when; fold the day count into \`when\`. A v2 wait is either a whole-day count or Advanced CEL, not both.`;
+}
+function sharedStepNameProblem(count) {
+  return `${count} step name(s) are claimed more than once. Touches and Endings are one namespace: until a save mints their uuids they address themselves by name and the definition resolves those keys through one field, and once saved they are stored steps the next run cannot tell apart. Names are canonical (trimmed), as the API stores them. Rename one.`;
+}
+function namelessStepProblem(count) {
+  return `${count} step(s) have an empty name once trimmed. A step's name is its request-local address until a save mints its uuid, so a nameless one has nothing to be addressed by, and the API refuses it. Name them.`;
+}
+function anchorKind(step) {
+  return step instanceof V2EndingBuilder ? "Ending" : "touch";
+}
+function buildV2Wait(wait, touchIndex) {
+  if (wait.afterDays !== void 0 && wait.when) {
+    throw new Error(waitExclusivityProblem(touchIndex));
+  }
+  const extras = {
+    ...wait.filterId !== void 0 ? { filterId: wait.filterId } : {}
+  };
+  if (wait.afterDays !== void 0) {
+    return { kind: "wholeDays", days: wait.afterDays, ...extras };
+  }
+  if (wait.when) {
+    return { kind: "advanced", cel: wait.when, ...extras };
+  }
+  return { kind: "none", ...extras };
+}
 
 // src/workspace-builder/role-update.ts
 var RoleUpdate = class extends WorkspaceBuilderResource {
@@ -1121,6 +1914,7 @@ var AgentBuilder = class extends WorkspaceBuilderResource {
     this.memberRoleId = options.roleId ?? options.role_id;
     this.tools = options.tools ?? [];
     this.codeInterpreterEnabled = options.codeInterpreterEnabled ?? options.code_interpreter_enabled ?? false;
+    this.webBrowserEnabled = options.webBrowserEnabled ?? options.web_browser_enabled ?? false;
   }
   name;
   chatModelId;
@@ -1128,6 +1922,7 @@ var AgentBuilder = class extends WorkspaceBuilderResource {
   memberRoleId;
   tools;
   codeInterpreterEnabled;
+  webBrowserEnabled;
   planLine() {
     const parts = [];
     if (this.chatModelId) parts.push(`model=${this.chatModelId}`);
@@ -1148,7 +1943,8 @@ var AgentBuilder = class extends WorkspaceBuilderResource {
       chatModelId: this.chatModelId,
       systemPrompt: this.systemPrompt,
       ...this.tools.length ? { tools: this.tools } : {},
-      ...this.codeInterpreterEnabled ? { codeInterpreterEnabled: true } : {}
+      ...this.codeInterpreterEnabled ? { codeInterpreterEnabled: true } : {},
+      ...this.webBrowserEnabled ? { webBrowserEnabled: true } : {}
     };
     const result = await client.createAgent(payload);
     this._id = result.id;
@@ -1169,6 +1965,9 @@ var PHASES = /* @__PURE__ */ new Map([
   [RoutineBuilder, 6],
   [NotificationRuleBuilder, 6],
   [JourneyBuilder, 7],
+  // Same phase as the legacy builder: a v2 Journey is written whole by its
+  // own apply(), so it has no child resources to sequence after it.
+  [JourneyV2Builder, 7],
   [JourneyStepBuilder, 8]
 ]);
 var LIST_PAGE_SIZE = 100;
@@ -1230,6 +2029,21 @@ var WorkspaceBuilder = class {
     this.resources.push(journey);
     return journey;
   }
+  /**
+   * A Journey v2 timeline (plan §3.8): ordered touches, structured waits, and
+   * ordered Endings, written through the atomic definition endpoint.
+   *
+   * A separate factory rather than an option on {@link journey}, because the
+   * two return different builders with different vocabularies — `.touch()`
+   * and `.ending()` versus `.step()` and `.connectsTo()`. The legacy builder
+   * keeps its current behaviour untouched, which is the plan's explicit
+   * compatibility requirement.
+   */
+  journeyV2(name, options = {}) {
+    const journey = new JourneyV2Builder(name, options);
+    this.resources.push(journey);
+    return journey;
+  }
   agent(name, options = {}) {
     const agent = new AgentBuilder(name, options);
     this.resources.push(agent);
@@ -1313,7 +2127,9 @@ ${"=".repeat(50)}`);
    * 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());
+    const problems = this.resources.filter(
+      (resource) => resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder
+    ).flatMap((journey) => journey.validate());
     if (!problems.length) return;
     writeLine("\n  Journey warnings:");
     for (const problem of problems) writeLine(`    ! ${problem}`);
@@ -1330,6 +2146,12 @@ ${"=".repeat(50)}`);
    * Deliberately narrow: only cross-resource facts the builder can see with
    * certainty. Per-field CEL schema checking stays server-side, where the
    * real validator lives — duplicating it here would drift.
+   *
+   * Pure: reads only what the plan declares, never what the server holds, so
+   * it is correct before adoption and safe for a caller to run directly. It
+   * is also the WHOLE gate: every anchor a v2 definition can name has a
+   * request-local address whether or not the server has seen it, so no
+   * refusal has to wait for adoption to decide it.
    */
   preflight() {
     const problems = [];
@@ -1353,39 +2175,46 @@ ${"=".repeat(50)}`);
         }
       }
     }
+    for (const resource of this.resources) {
+      if (resource instanceof JourneyV2Builder) problems.push(...resource.preflight());
+    }
     return [...new Set(problems)];
   }
-  async apply() {
-    const problems = this.preflight();
-    if (problems.length) {
-      writeLine("\nPlan rejected \u2014 nothing was created:");
-      for (const problem of problems) writeLine(`  ! ${problem}`);
-      throw new Error(
-        `Plan has ${problems.length} problem(s) and was not applied:
+  /** The plan-rejection shape: every problem printed, nothing written. */
+  rejectIfProblems(problems) {
+    if (!problems.length) return;
+    writeLine("\nPlan rejected \u2014 nothing was created:");
+    for (const problem of problems) writeLine(`  ! ${problem}`);
+    throw new Error(
+      `Plan has ${problems.length} problem(s) and was not applied:
 ` + problems.map((problem) => `  - ${problem}`).join("\n")
-      );
-    }
+    );
+  }
+  async apply() {
     const resources = this.sortedResources();
+    this.rejectIfProblems(this.preflight());
     await this.resolveExisting(resources);
     const summary = {};
     writeLine("Applying...");
     for (const resource of resources) {
       try {
         if (resource.isImplicit) continue;
-        if (resource._existed) {
+        if (resource._existed && !resource.appliesWhenExisting) {
           const key = resourceKey(resource);
           summary[key] ??= [];
           summary[key].push(resource._id);
           writeLine(`  Exists ${resource.planLine()} -> id=${resource._id}`);
           continue;
         }
+        const updating = resource._existed;
         await resource.apply(this.client);
         if (resource._created || resource._id !== void 0) {
           const key = resourceKey(resource);
           summary[key] ??= [];
           summary[key].push(resource._id);
           const startTag = resource instanceof TaskBuilder && resource.start ? " [start]" : "";
-          writeLine(`  Created ${resource.planLine()}${startTag} -> id=${resource._id}`);
+          const verb = updating ? "Updated" : "Created";
+          writeLine(`  ${verb} ${resource.planLine()}${startTag} -> id=${resource._id}`);
         } else {
           writeLine(`  Skipped: ${resource.planLine()}`);
         }
@@ -1404,6 +2233,11 @@ Done! Created ${count} resources.`);
     return summary;
   }
   async resolveExisting(resources) {
+    assertUniqueJourneyNames(
+      resources.filter(
+        (resource) => resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder
+      )
+    );
     const formSlugs = new Map(
       resources.filter((resource) => resource instanceof FormBuilder).map((resource) => [resource.slug, resource])
     );
@@ -1442,14 +2276,33 @@ Done! Created ${count} resources.`);
       }
     }
     const journeyNames = new Map(
-      resources.filter((resource) => resource instanceof JourneyBuilder).map((resource) => [resource.name, resource])
+      resources.filter(
+        (resource) => resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder
+      ).map((resource) => [resource.name, resource])
     );
     if (journeyNames.size) {
-      const existingJourneys = await this.client.getJourneys();
-      for (const existing of existingJourneys.items) {
+      const pageSize = 500;
+      const firstPage = await this.client.getJourneys(false, { page: 1, pageSize });
+      const allJourneys = [...firstPage.items];
+      for (let page = 2; page <= firstPage.totalPages; page++) {
+        const nextPage = await this.client.getJourneys(false, { page, pageSize });
+        allJourneys.push(...nextPage.items);
+      }
+      const storedByName = /* @__PURE__ */ new Map();
+      for (const existing of allJourneys) {
         if (!existing.name || !journeyNames.has(existing.name)) continue;
-        const detail = await this.client.getJourney(existing.id);
-        journeyNames.get(existing.name).adopt(detail);
+        storedByName.set(existing.name, [...storedByName.get(existing.name) ?? [], existing]);
+      }
+      for (const [name, matches] of storedByName) {
+        if (matches.length > 1) {
+          throw new Error(
+            `This workspace has ${matches.length} journeys named '${name}', and the script adopts an existing journey by name \u2014 so it cannot tell which one it owns. Adopting the wrong one replaces that journey whole on the next save. Rename the others in the app, or rename the journey in the script.`
+          );
+        }
+        const existing = matches[0];
+        const builder = journeyNames.get(name);
+        const detail = builder instanceof JourneyV2Builder ? await this.client.getJourneyAuthoring(existing.id) : await this.client.getJourney(existing.id);
+        builder.adopt(detail);
       }
     }
     const agentNames = new Map(
@@ -1628,6 +2481,12 @@ Done! Created ${count} resources.`);
         }
       } else if (resource instanceof JourneyBuilder) {
         for (const goal of resource.goals) lines.push(`Goal: ${goal.name}`);
+      } else if (resource instanceof JourneyV2Builder) {
+        resource.touches.forEach((touch, index) => {
+          lines.push(`${index + 1}. ${touch.name}`);
+        });
+        for (const ending of resource.endings) lines.push(`Ending: ${ending.name}`);
+        for (const goal of resource.goals) lines.push(`Goal: ${goal.name}`);
       }
     }
     return lines;
@@ -1786,6 +2645,17 @@ var ApplyError = class extends Error {
     return this.#cause;
   }
 };
+function assertUniqueJourneyNames(journeys) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const journey of journeys) {
+    if (seen.has(journey.name)) {
+      throw new Error(
+        `This script declares two journeys named '${journey.name}'. A journey is adopted and re-applied by name, so only one of them could ever be written \u2014 and a v2 apply replaces the journey it adopted whole. Rename one.`
+      );
+    }
+    seen.add(journey.name);
+  }
+}
 function resourceKey(resource) {
   if (resource instanceof RoleUpdate) return "roleUpdates";
   if (resource instanceof FormBuilder) return "forms";
@@ -1795,7 +2665,9 @@ function resourceKey(resource) {
   if (resource instanceof MemberFilterBuilder) return "memberFilters";
   if (resource instanceof RoutineBuilder) return "routines";
   if (resource instanceof NotificationRuleBuilder) return "notificationRules";
-  if (resource instanceof JourneyBuilder) return "journeys";
+  if (resource instanceof JourneyBuilder || resource instanceof JourneyV2Builder) {
+    return "journeys";
+  }
   if (resource instanceof JourneyStepBuilder) return "journeySteps";
   if (resource instanceof AgentBuilder) return "agents";
   return "resources";
@@ -1906,7 +2778,7 @@ function writeScopeForResource(resource) {
   if (resource instanceof RoutineBuilder || resource instanceof NotificationRuleBuilder) {
     return "automations:admin";
   }
-  if (resource instanceof JourneyBuilder || resource instanceof JourneyStepBuilder) {
+  if (resource instanceof JourneyBuilder || resource instanceof JourneyStepBuilder || resource instanceof JourneyV2Builder) {
     return "journeys:write";
   }
   if (resource instanceof RoleUpdate) return "member_roles:write";
@@ -1970,6 +2842,112 @@ async function runWorkspaceScript(client, build, mode = "plan") {
   if (mode === "apply") return workspace.apply();
   throw new Error(`Unknown mode '${mode}'. Use plan, preview, or apply.`);
 }
+
+// src/types/generated/event_type.ts
+var ActivityCapability = {
+  "assignments:read": "assignments:read",
+  "chats:read": "chats:read",
+  "journeys:read": "journeys:read",
+  "members:read": "members:read",
+  "operator:read": "operator:read",
+  "org:read": "org:read",
+  "phones:read": "phones:read",
+  "workflows:read": "workflows:read",
+  "workspace:read": "workspace:read"
+};
+var ActivityEventType = {
+  membercreated: "member.created",
+  memberremoved: "member.removed",
+  memberrole_changed: "member.role_changed",
+  memberlabels_changed: "member.labels_changed",
+  memberattributes_changed: "member.attributes_changed",
+  importstarted: "import.started",
+  importcompleted: "import.completed",
+  assignmentstarted: "assignment.started",
+  assignmentconcluded: "assignment.concluded",
+  journeyenrolled: "journey.enrolled",
+  journeyunenrolled: "journey.unenrolled",
+  journeycompleted: "journey.completed",
+  journeystep_transitioned: "journey.step_transitioned",
+  journeyactivated: "journey.activated",
+  chatstarted: "chat.started",
+  chatawaiting_human: "chat.awaiting_human",
+  chathuman_replied: "chat.human_replied",
+  chatcall_ended: "chat.call_ended",
+  escalationopened: "escalation.opened",
+  escalationresolved: "escalation.resolved",
+  callstarted: "call.started",
+  callcompleted: "call.completed",
+  callmissed: "call.missed",
+  presencewent_online: "presence.went_online",
+  presencewent_offline: "presence.went_offline",
+  operator_groupmember_added: "operator_group.member_added",
+  operator_groupmember_removed: "operator_group.member_removed",
+  voicemailreceived: "voicemail.received",
+  voicemaillistened: "voicemail.listened",
+  routinestarted: "routine.started",
+  routinecompleted: "routine.completed",
+  routinefailed: "routine.failed",
+  workflowpublished: "workflow.published",
+  subscriptionstarted: "subscription.started",
+  subscriptionupdated: "subscription.updated",
+  subscriptioncanceled: "subscription.canceled",
+  member_subscriptionstarted: "member_subscription.started",
+  member_subscriptioncanceled: "member_subscription.canceled",
+  purchasecompleted: "purchase.completed",
+  phone_numberprovisioned: "phone_number.provisioned",
+  phone_numberarchived: "phone_number.archived",
+  domainlinked: "domain.linked",
+  domainverified: "domain.verified",
+  configupdated: "config.updated"
+};
+var ActivityVisibility = {
+  workspace: "workspace",
+  org: "org",
+  account_private: "account_private"
+};
+
+// src/types/generated/ref.ts
+var ActorKind = {
+  account: "account",
+  agent: "agent",
+  connection: "connection",
+  member: "member",
+  org_account: "org_account",
+  system: "system"
+};
+var EntityKind = {
+  account: "account",
+  org: "org",
+  org_account: "org_account",
+  workspace: "workspace",
+  agent: "agent",
+  connection: "connection",
+  member: "member",
+  assignment: "assignment",
+  journey: "journey",
+  journey_step: "journey_step",
+  routine: "routine",
+  task: "task",
+  workflow: "workflow",
+  workflow_revision: "workflow_revision",
+  call: "call",
+  chat: "chat",
+  escalation: "escalation",
+  inbox: "inbox",
+  phone_number: "phone_number",
+  voicemail: "voicemail",
+  domain: "domain",
+  import: "import",
+  invoice: "invoice",
+  member_label: "member_label",
+  member_subscription: "member_subscription",
+  operator_group: "operator_group",
+  purchase: "purchase",
+  subscription: "subscription",
+  data_type: "data_type",
+  workspace_config: "workspace_config"
+};
 export {
   AGENT_NOTE_ORIGINS,
   AbilityConfigIssueCode,
@@ -1979,6 +2957,16 @@ export {
   AccessGrantStatus,
   AccessGrantTrigger,
   AccessLevel,
+  ActivityCapability,
+  ActivityEventFamily,
+  ActivityEventType,
+  ActivityGrain,
+  ActivityGroupBy,
+  ActivityOpenItemOrder,
+  ActivityOutcome,
+  ActivityVisibility,
+  ActivityWindowBasis,
+  ActorKind,
   AgentBuilder,
   ApiError,
   ApplyError,
@@ -1999,8 +2987,16 @@ export {
   CalendarScheduleRecurrence,
   CalendarSource,
   CapabilityClass,
+  ChannelMessageDirection,
+  ChannelMessageSource,
+  ChannelMessagesUnavailableReason,
+  ChatInteractionController,
+  ChatMuteReason,
   ConsentMethod,
   CriterionType,
+  DEFAULT_AGENT_CHAT_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL,
+  DEFAULT_AGENT_REALTIME_MODEL_CONFIG,
   DEFAULT_CHAT_MODEL,
   DEFAULT_CUSTOM_VOICE_MODEL,
   DEFAULT_THINKING_SPEECH_PHRASES,
@@ -2010,8 +3006,11 @@ export {
   DataRecordRetirementResponseReason,
   DataSensitivity,
   DataTypeRecordScope,
+  DigestSlotRole,
   DriverMode,
+  EhrWritebackOutcomeResponseStatus,
   EmailDnsRecordType,
+  EntityKind,
   EventRuleActionType,
   EventRuleEventType,
   EventRuleObjectType,
@@ -2022,6 +3021,11 @@ export {
   FhirVendor,
   FormBuilder,
   GravityRailClient,
+  ImportSkippedRuleResourceGroupResourceType,
+  ImportSkippedRuleResponseNeededResourceTypesItem,
+  ImportSkippedRuleResponseParentKind,
+  ImportSkippedRuleResponseReasonCode,
+  ImportSkippedRuleResponseStatus,
   InboundFaxStatus as InboundFaxStatusValues,
   IndexStatus,
   InvitationStatus,
@@ -2029,6 +3033,7 @@ export {
   JourneyBuilder,
   JourneyStepBuilder,
   MASKED_SECRET_SENTINEL,
+  MEMBER_RELATIONSHIP_KINDS,
   McpServerState,
   MemberFeature,
   MemberFilterBuilder,
@@ -2036,6 +3041,7 @@ export {
   MemberImportPreviewRowAction,
   MemberImportValidationError,
   MemberLabelBuilder,
+  MemberRelationshipKind,
   MemberType,
   MenuItemResponseItemType,
   MenuItemResponseItemType as MenuItemType,
@@ -2071,8 +3077,11 @@ export {
   REALTIME_MODEL_OPENAI,
   REALTIME_MODEL_OPENAI_2,
   REALTIME_MODEL_OPENAI_MINI,
+  RefResolutionStatus,
   Region,
   RegistrationIdentifier,
+  RelatedMemberRole,
+  RelationshipCardinality,
   Resource,
   RoleUpdate,
   RoutineBuilder,
@@ -2097,7 +3106,12 @@ export {
   TTS_PREVIEW_PROVIDERS,
   TaskBuilder,
   TemplatesApi,
+  TestChatRunLane,
+  TestChatRunOutcome,
   ToolkitState,
+  UiPromptPresentedKind as UiPromptPresentedKindValues,
+  UiPromptResponseKind as UiPromptResponseKindValues,
+  UiPromptResponseStatus as UiPromptResponseStatusValues,
   WIDGET_SLUGS,
   WORKFLOW_IMPLICIT_USE_SCOPE,
   WorkflowAccessWarningResourceType,