@gravity-rail/sdk 0.7.1 → 0.7.3

package/dist/index.cjs

@@ -27,7 +27,9 @@ __export(src_exports, {
   AccessGrantStatus: () => AccessGrantStatus,
   AccessGrantTrigger: () => AccessGrantTrigger,
   AccessLevel: () => AccessLevel2,
+  AgentBuilder: () => AgentBuilder,
   ApiError: () => ApiError,
+  ApplyError: () => ApplyError,
   AppsApi: () => AppsApi,
   AttendeeResponseStatus: () => AttendeeResponseStatus,
   AttendeeStatus: () => AttendeeStatus,
@@ -64,19 +66,25 @@ __export(src_exports, {
   FhirClientType: () => FhirClientType,
   FhirConnectionState: () => FhirConnectionState,
   FhirVendor: () => FhirVendor,
+  FormBuilder: () => FormBuilder,
   GravityRailClient: () => GravityRailClient,
   IndexStatus: () => IndexStatus,
   InvitationStatus: () => InvitationStatus,
   JobPosition: () => JobPosition,
+  JourneyBuilder: () => JourneyBuilder,
+  JourneyStepBuilder: () => JourneyStepBuilder,
   MASKED_SECRET_SENTINEL: () => MASKED_SECRET_SENTINEL,
   McpServerState: () => McpServerState,
   MemberFeature: () => MemberFeature,
+  MemberFilterBuilder: () => MemberFilterBuilder,
+  MemberLabelBuilder: () => MemberLabelBuilder,
   MemberType: () => MemberType,
   MenuItemResponseItemType: () => MenuItemResponseItemType,
   MenuItemType: () => MenuItemResponseItemType,
   ModelProvider: () => ModelProvider,
   ModelType: () => ModelType,
   NO_ASSISTANT_PARTICIPANT_CHAT_TYPES: () => NO_ASSISTANT_PARTICIPANT_CHAT_TYPES,
+  NotificationRuleBuilder: () => NotificationRuleBuilder,
   OIDCAdminConfigViewProviderType: () => OIDCAdminConfigViewProviderType,
   ORG_ONLY_RESOURCES: () => ORG_ONLY_RESOURCES,
   OrgApi: () => OrgApi,
@@ -102,6 +110,8 @@ __export(src_exports, {
   Region: () => Region,
   RegistrationIdentifier: () => RegistrationIdentifier,
   Resource: () => Resource,
+  RoleUpdate: () => RoleUpdate,
+  RoutineBuilder: () => RoutineBuilder,
   SCOPES: () => SCOPES,
   SCOPE_PRESETS: () => SCOPE_PRESETS,
   SMS_DELIVERY_FAILURE_STATUSES: () => SMS_DELIVERY_FAILURE_STATUSES,
@@ -121,15 +131,19 @@ __export(src_exports, {
   TTS_MODEL_ELEVENLABS_TURBO: () => TTS_MODEL_ELEVENLABS_TURBO,
   TTS_MODEL_POCKET: () => TTS_MODEL_POCKET,
   TTS_PREVIEW_PROVIDERS: () => TTS_PREVIEW_PROVIDERS,
+  TaskBuilder: () => TaskBuilder,
   TemplatesApi: () => TemplatesApi,
   ToolkitState: () => ToolkitState,
   WorkflowAccessWarningResourceType: () => WorkflowAccessWarningResourceType,
+  WorkflowBuilder: () => WorkflowBuilder,
   WorkflowResourceType: () => WorkflowAccessWarningResourceType,
+  WorkspaceBuilder: () => WorkspaceBuilder,
   WorkspaceFeature: () => WorkspaceFeature,
   WorkspaceProvisionStatus: () => WorkspaceProvisionStatus,
   areDependenciesSatisfied: () => areDependenciesSatisfied,
   canPreviewVoice: () => canPreviewVoice,
   clearRegistry: () => clearRegistry,
+  createWorkspaceClient: () => createWorkspaceClient,
   decodePermissions: () => decodePermissions,
   encodePermissions: () => encodePermissions,
   eventRuleActionParams: () => eventRuleActionParams,
@@ -154,6 +168,7 @@ __export(src_exports, {
   isRegistryInitialized: () => isRegistryInitialized,
   isSMSDeliveryFailureStatus: () => isSMSDeliveryFailureStatus,
   requiresAssistantParticipant: () => requiresAssistantParticipant,
+  runWorkspaceScript: () => runWorkspaceScript,
   usesBuiltinAssistant: () => usesBuiltinAssistant,
   validateFeatureDependencies: () => validateFeatureDependencies
 });
@@ -778,6 +793,13 @@ var AgentsApi = class extends BaseApiClient {
       method: "POST"
     });
   }
+  /** Resolve runtime tools for an agent on a simulated channel. */
+  async resolveAgentTools(wid, id, options) {
+    const params = new URLSearchParams();
+    params.append("channel", options.channel);
+    params.append("taskId", options.taskId.toString());
+    return this.fetch(`w/${wid}/agents/${id}/resolve-tools?${params}`);
+  }
 };
 
 // src/api/ai-models.ts
@@ -1712,6 +1734,23 @@ var CalendarsApi = class extends BaseApiClient {
 
 // src/api/calls.ts
 var CallsApi = class extends BaseApiClient {
+  /** List workspace phone calls with optional filtering. */
+  async getPhoneCalls(wid, options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.set("page", String(options.page));
+    if (options.pageSize) params.set("pageSize", String(options.pageSize));
+    if (options.phoneNumberId !== void 0)
+      params.set("phoneNumberId", String(options.phoneNumberId));
+    if (options.chatId !== void 0) params.set("chatId", String(options.chatId));
+    if (options.workflowId !== void 0) params.set("workflowId", String(options.workflowId));
+    if (options.status) params.set("status", options.status);
+    if (options.inbound !== void 0) params.set("inbound", String(options.inbound));
+    if (options.dateFrom) params.set("dateFrom", options.dateFrom);
+    if (options.dateTo) params.set("dateTo", options.dateTo);
+    return this.fetch(
+      `w/${wid}/calls${params.toString() ? `?${params.toString()}` : ""}`
+    );
+  }
   /** Initiate a new outbound call. */
   async initiateCall(wid, request) {
     return this.fetch(`w/${wid}/call`, {
@@ -2236,10 +2275,17 @@ var DataTypesApi = class extends BaseApiClient {
     const queryString = params.toString();
     return this.fetch(`w/${wid}/data-types${queryString ? `?${queryString}` : ""}`);
   }
-  /** Get a single data type by ID. */
+  /** Get a single data type by numeric ID, or by UUID when a UUID string is supplied. */
   async getDataType(wid, id) {
+    if (typeof id === "string" && isUuid(id)) {
+      return this.getDataTypeByUuid(wid, id);
+    }
     return this.fetch(`w/${wid}/data-types/${id}`);
   }
+  /** Get a single data type by UUID. */
+  async getDataTypeByUuid(wid, uuid) {
+    return this.fetch(`w/${wid}/data-types/${uuid}`);
+  }
   /** Get a single data type by its slug. */
   async getDataTypeBySlug(wid, slug) {
     return this.fetch(`w/${wid}/data-types/slug/${slug}`);
@@ -2366,6 +2412,9 @@ var DataTypesApi = class extends BaseApiClient {
     return this.fetch(`w/${wid}/data-types/member-record-counts?member_id=${memberId}`);
   }
 };
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
 
 // src/api/discord-bots.ts
 var DiscordBotsApi = class extends BaseApiClient {
@@ -3293,6 +3342,25 @@ var FilesApi = class extends BaseApiClient {
       body: JSON.stringify(file)
     });
   }
+  /** Upload in-memory file content through the API's database-backed file path. */
+  async uploadFile(wid, request) {
+    const mimeType = request.mimeType ?? "application/octet-stream";
+    const bytes = await dataToBytes(request.data);
+    return this.createFile(wid, {
+      title: request.title ?? request.filename,
+      filename: request.filename,
+      description: request.description,
+      mimeType,
+      folderId: request.folderId,
+      siteId: request.siteId,
+      dataBase64: bytesToBase64(bytes),
+      externalId: request.externalId,
+      oauthCredentialUuid: request.oauthCredentialUuid,
+      access: request.access,
+      labelIds: request.labelIds,
+      overwrite: request.overwrite
+    });
+  }
   /** Update an existing file's metadata. */
   async updateFile(wid, id, file) {
     return this.fetch(`w/${wid}/files/${id}`, {
@@ -3473,6 +3541,38 @@ var FilesApi = class extends BaseApiClient {
     );
   }
 };
+async function dataToBytes(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw new Error("Unsupported file data type");
+}
+function bytesToBase64(bytes) {
+  if (typeof btoa === "function") {
+    const chunkSize = 32768;
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  throw new Error("No base64 encoder is available in this runtime");
+}
 
 // src/api/inboxes.ts
 var InboxesApi = class extends BaseApiClient {
@@ -6623,6 +6723,36 @@ var JourneysApi = class extends BaseApiClient {
   async getMemberJourneys(wid, memberId) {
     return this.fetch(`w/${wid}/journeys/by-member/${memberId}`);
   }
+  /** List members currently or historically associated with one journey step. */
+  async getStepMembers(wid, journeyId, stepUuid, params = {}) {
+    const qs = new URLSearchParams();
+    if (params.status) qs.set("status", params.status);
+    if (params.mode) qs.set("mode", params.mode);
+    if (params.page) qs.set("page", String(params.page));
+    if (params.pageSize) qs.set("pageSize", String(params.pageSize));
+    const query = qs.toString();
+    return this.fetch(
+      `w/${wid}/journeys/${journeyId}/steps/${stepUuid}/members${query ? `?${query}` : ""}`
+    );
+  }
+  /** Get member counts by status for each journey step. */
+  async getStepMemberCounts(wid, journeyId) {
+    return this.fetch(`w/${wid}/journeys/${journeyId}/step-member-counts`);
+  }
+  /** Advance a journey step in the current execution context. */
+  async advanceStep(wid, journeyId, stepUuid, data = {}) {
+    return this.fetch(
+      `w/${wid}/journeys/${journeyId}/steps/${stepUuid}/advance`,
+      { method: "POST", body: JSON.stringify(data) }
+    );
+  }
+  /** Skip a journey step in the current execution context. */
+  async skipStep(wid, journeyId, stepUuid, data = {}) {
+    return this.fetch(
+      `w/${wid}/journeys/${journeyId}/steps/${stepUuid}/skip`,
+      { method: "POST", body: JSON.stringify(data) }
+    );
+  }
   /**
    * Dry-run heartbeat CEL evaluation for an enrolled member.
    *
@@ -8092,6 +8222,714 @@ function createApiModules(apiKey, baseUrl, customFetch) {
   };
 }
 
+// src/client/workspace-client.ts
+var WORKSPACE_METHOD_NAMES = [
+  "activateWorkflowVersion",
+  "addGroupMember",
+  "advanceStep",
+  "approveWorkspaceInvitation",
+  "archiveAgent",
+  "archiveChat",
+  "archiveDataType",
+  "archiveJourney",
+  "archiveMember",
+  "archivePhoneNumber",
+  "archiveStep",
+  "archiveTask",
+  "archiveWorkflow",
+  "authorizeMondayConnection",
+  "autoCreateDataTypeFromBoard",
+  "blockWorkspaceInvitation",
+  "bookHealthieAppointment",
+  "buildWorkspace",
+  "bulkLinkMembersToHubspot",
+  "bulkLinkMembersToMonday",
+  "bulkLinkMembersToSalesforce",
+  "cancelAgentTask",
+  "cancelAssignment",
+  "cancelCalendarEvent",
+  "cancelCredentialUpdateInvite",
+  "checkAvailability",
+  "checkSiteDomainAvailability",
+  "checkSiteSlugAvailability",
+  "clearConnectionMemberExclusion",
+  "clearMemberSwitch",
+  "clickWorkspaceSupportRequestResource",
+  "cloneDataType",
+  "cloneTask",
+  "cloneWorkflow",
+  "closeWorkspaceSupportRequest",
+  "commentOnWorkspaceSupportRequest",
+  "configureConfluence",
+  "configureHealthie",
+  "configureHubspot",
+  "configureMondayConnection",
+  "configureSalesforce",
+  "convertEmail",
+  "convertFile",
+  "crawlSite",
+  "createAccessGrant",
+  "createAgent",
+  "createApiKey",
+  "createAssignment",
+  "createCalendar",
+  "createCalendarEvent",
+  "createCalendarSchedule",
+  "createChat",
+  "createChatCompletion",
+  "createChatFilter",
+  "createChatLabel",
+  "createClientWorkspace",
+  "createConnection",
+  "createCustomTool",
+  "createCustomToolkit",
+  "createDataRecord",
+  "createDataType",
+  "createDiscordBot",
+  "createEventRule",
+  "createEventType",
+  "createExperiment",
+  "createExperimentAssignment",
+  "createExperimentGroup",
+  "createFhirConnection",
+  "createFile",
+  "createFileLabel",
+  "createFolder",
+  "createGoal",
+  "createInbox",
+  "createJourney",
+  "createJourneyNote",
+  "createMcpServer",
+  "createMemberField",
+  "createMemberFilter",
+  "createMemberLabel",
+  "createMemberMemory",
+  "createMemberRole",
+  "createMenuItem",
+  "createMilestone",
+  "createNotificationRule",
+  "createOperatorGroup",
+  "createPage",
+  "createPersona",
+  "createPhoneNumber",
+  "createProduct",
+  "createRoutine",
+  "createScenario",
+  "createSignup",
+  "createSite",
+  "createSlackApp",
+  "createSnippet",
+  "createStep",
+  "createSupervisor",
+  "createTask",
+  "createTeamsApp",
+  "createWorkflow",
+  "createWorkflowContributor",
+  "createWorkflowFromTemplate",
+  "createWorkflowNote",
+  "createWorkflowOutboundVoiceChat",
+  "createWorkspaceMember",
+  "createWorkspaceSupportRequest",
+  "deactivateWorkflowVersion",
+  "deleteAgent",
+  "deleteAssignment",
+  "deleteCalendar",
+  "deleteCalendarEvent",
+  "deleteCalendarSchedule",
+  "deleteChat",
+  "deleteChatFilter",
+  "deleteChatLabel",
+  "deleteClientWorkspace",
+  "deleteConfluence",
+  "deleteConnection",
+  "deleteCustomTool",
+  "deleteCustomToolkit",
+  "deleteDataRecord",
+  "deleteDataType",
+  "deleteDiscordBot",
+  "deleteEnrollment",
+  "deleteEventRule",
+  "deleteEventType",
+  "deleteExperiment",
+  "deleteExperimentAssignment",
+  "deleteExperimentGroup",
+  "deleteFhirConnection",
+  "deleteFile",
+  "deleteFileLabel",
+  "deleteFolder",
+  "deleteGoal",
+  "deleteHubspot",
+  "deleteInbox",
+  "deleteJourneyNote",
+  "deleteMcpServer",
+  "deleteMember",
+  "deleteMemberField",
+  "deleteMemberFilter",
+  "deleteMemberLabel",
+  "deleteMemberMemory",
+  "deleteMemberRole",
+  "deleteMenuItem",
+  "deleteMilestone",
+  "deleteMondayConnection",
+  "deleteNotificationRule",
+  "deleteOperatorGroup",
+  "deletePage",
+  "deletePersona",
+  "deletePlatformApp",
+  "deleteProduct",
+  "deleteRoutine",
+  "deleteSalesforce",
+  "deleteScenario",
+  "deleteSite",
+  "deleteSlackApp",
+  "deleteSnippet",
+  "deleteSupervisor",
+  "deleteTask",
+  "deleteTeamsApp",
+  "deleteWorkflow",
+  "deleteWorkflowContributor",
+  "deleteWorkflowNote",
+  "deleteWorkspace",
+  "deleteWorkspaceInvitationAdmin",
+  "denyWorkspaceInvitation",
+  "describeSalesforceObject",
+  "diffWorkflowVersions",
+  "disableConfluence",
+  "disableCustomToolkit",
+  "disableHubspot",
+  "disableMcpServer",
+  "disableMondayConnection",
+  "disableSalesforce",
+  "disconnectConfluence",
+  "disconnectHubspot",
+  "disconnectMondayConnection",
+  "disconnectPresence",
+  "disconnectSalesforce",
+  "discoverOAuthMetadata",
+  "dismissAllNotifications",
+  "dismissNotification",
+  "downloadEmailAttachment",
+  "enableConfluence",
+  "enableCustomToolkit",
+  "enableHubspot",
+  "enableMcpServer",
+  "enableMondayConnection",
+  "enablePlatformApp",
+  "enableSalesforce",
+  "endTestChatRun",
+  "enrollMembers",
+  "evaluateTestChatRun",
+  "executeAssignmentTool",
+  "expireAnonymousMember",
+  "exportChat",
+  "exportChats",
+  "exportMembers",
+  "exportWorkspace",
+  "fetchVoicemailAudio",
+  "fhirBackfillEncounterSync",
+  "fhirCreateEncounter",
+  "fhirCsvImportApply",
+  "fhirCsvImportInspect",
+  "fhirFetchCareTeam",
+  "fhirFetchEncounters",
+  "fhirGetCsvImportRunItems",
+  "fhirGetCsvImportRuns",
+  "fhirGetCsvImportSettings",
+  "fhirGetEncounterSyncRuns",
+  "fhirGetEncounterSyncStatus",
+  "fhirImportPatient",
+  "fhirLinkMember",
+  "fhirListLinkedMembers",
+  "fhirRefreshEncounterPatient",
+  "fhirRunEncounterSync",
+  "fhirSearchLocations",
+  "fhirSearchPatients",
+  "fhirSearchPractitioners",
+  "fhirSyncMember",
+  "fhirUnlinkMember",
+  "fhirUpdateCsvImportSettings",
+  "fhirUpdateEncounterSync",
+  "findOrCreateDMChat",
+  "generateFileUploadUrl",
+  "generateICalToken",
+  "generateSiteMediaUploadUrl",
+  "getAIUsageReport",
+  "getAbilityTypes",
+  "getAccessGrant",
+  "getAccessGrants",
+  "getAgent",
+  "getAgentTask",
+  "getAgentTaskMessages",
+  "getAgentTasks",
+  "getAgents",
+  "getAnonymousResolution",
+  "getAnonymousResolutions",
+  "getApiKeys",
+  "getArchiveBlockers",
+  "getAssignment",
+  "getAssignmentCelContext",
+  "getAssignmentMessages",
+  "getAssignmentTask",
+  "getAssignmentTaskDetail",
+  "getAssignmentTools",
+  "getAssignments",
+  "getAvailableActions",
+  "getAvailablePhoneNumbers",
+  "getAvailableSlots",
+  "getBoardColumns",
+  "getBoardGroups",
+  "getBoards",
+  "getBusinessHoursStatus",
+  "getCalendar",
+  "getCalendarEvent",
+  "getCalendarEvents",
+  "getCalendarSchedules",
+  "getCalendars",
+  "getCelContext",
+  "getChat",
+  "getChatAssignmentTasks",
+  "getChatEmails",
+  "getChatFilter",
+  "getChatFilterByUuid",
+  "getChatFilterCount",
+  "getChatFilters",
+  "getChatLabel",
+  "getChatLabelByUuid",
+  "getChatLabels",
+  "getChatMessages",
+  "getChatPhoneCalls",
+  "getChatSkills",
+  "getChatTodos",
+  "getChatTokenUsage",
+  "getChatToolCallMessages",
+  "getChatTools",
+  "getChats",
+  "getChatsDailyCreationStats",
+  "getChatsNeedsResponse",
+  "getClientWorkspace",
+  "getConfluenceStatus",
+  "getConnectionSyncCapabilities",
+  "getConnectionSyncCheckpoint",
+  "getConnectionSyncConfig",
+  "getCredentialUpdateInvites",
+  "getCurrentMember",
+  "getCurrentUserInfo",
+  "getCustomToolkit",
+  "getCustomToolkits",
+  "getDataRecord",
+  "getDataRecordChanges",
+  "getDataRecords",
+  "getDataType",
+  "getDataTypeByUuid",
+  "getDataTypeBySlug",
+  "getDataTypes",
+  "getDiscordBot",
+  "getDiscordBotAccounts",
+  "getDiscordBotByUuid",
+  "getDiscordBots",
+  "getDiscordGuilds",
+  "getDiscordThreads",
+  "getEventRule",
+  "getEventRules",
+  "getEventType",
+  "getEventTypes",
+  "getExperiment",
+  "getExperimentStats",
+  "getExperiments",
+  "getFhirConnection",
+  "getFhirConnectionByUuid",
+  "getFhirConnections",
+  "getFieldIndexStatus",
+  "getFile",
+  "getFileLabel",
+  "getFileLabelByUuid",
+  "getFileLabels",
+  "getFileSharing",
+  "getFiles",
+  "getFirstRunState",
+  "getFolder",
+  "getFolderSharing",
+  "getFolders",
+  "getGoogleCalendarStatus",
+  "getHealthieAvailableSlots",
+  "getHealthieReconciliationMatches",
+  "getHealthieStatus",
+  "getHubspotContactProperties",
+  "getHubspotManagedRules",
+  "getHubspotReconciliationMatches",
+  "getHubspotStatus",
+  "getHubspotSyncLogs",
+  "getHubspotTransformPresets",
+  "getICalFeedUrl",
+  "getInbox",
+  "getInboxEmail",
+  "getInboxEmails",
+  "getInboxThreads",
+  "getInboxes",
+  "getJourney",
+  "getJourneyHealth",
+  "getJourneyMembers",
+  "getJourneyNotes",
+  "getJourneys",
+  "getLinkablePhones",
+  "getLinkedHealthieMembers",
+  "getLinkedHubspotMembers",
+  "getLinkedMondayMembers",
+  "getLinkedRecords",
+  "getLinkedSalesforceMembers",
+  "getLiveOperators",
+  "getMcpServer",
+  "getMcpServerPrompts",
+  "getMcpServerResources",
+  "getMcpServerTools",
+  "getMcpServers",
+  "getMemberExperiments",
+  "getMemberFieldDefinitions",
+  "getMemberFields",
+  "getMemberFilter",
+  "getMemberFilterCount",
+  "getMemberFilters",
+  "getMemberGrants",
+  "getMemberJourneys",
+  "getMemberLabel",
+  "getMemberLabelByUuid",
+  "getMemberLabels",
+  "getMemberMemories",
+  "getMemberRecordCounts",
+  "getMemberRole",
+  "getMemberRoleByUuid",
+  "getMemberRoles",
+  "getMemberSyncSummary",
+  "getMemberUsage",
+  "getMembersMessageActivity",
+  "getMenuItems",
+  "getMessageTiming",
+  "getMilestone",
+  "getMilestones",
+  "getMondayConnectionBoardColumns",
+  "getMondayConnectionBoardGroups",
+  "getMondayConnectionBoards",
+  "getMondayConnectionStatus",
+  "getMondayReconciliationMatches",
+  "getMondaySyncConfig",
+  "getMyCredentials",
+  "getMyGivenGrants",
+  "getMyReceivedGrants",
+  "getNotification",
+  "getNotificationRules",
+  "getNotifications",
+  "getOperatorChatMessages",
+  "getOperatorGroup",
+  "getOperatorGroups",
+  "getOrCreateQualificationForWorkflow",
+  "getOwnedMembers",
+  "getPage",
+  "getPageBySlug",
+  "getPersona",
+  "getPhoneCalls",
+  "getPhoneNumber",
+  "getPhoneNumberCalls",
+  "getPhoneNumberMessages",
+  "getPhoneNumberVoicemails",
+  "getPhoneNumbers",
+  "getPhoneUsageReport",
+  "getPlatformApp",
+  "getPresenceStatus",
+  "getProducts",
+  "getPublicFile",
+  "getPublicFolder",
+  "getPublicFolderFiles",
+  "getPublicProducts",
+  "getQualification",
+  "getQualifications",
+  "getResellerWorkspaces",
+  "getRoutine",
+  "getRoutineRuns",
+  "getRoutines",
+  "getRuleExecutions",
+  "getSMSUsageReport",
+  "getSalesforceReconciliationMatches",
+  "getSalesforceStatus",
+  "getSalesforceSyncConfig",
+  "getScenario",
+  "getSite",
+  "getSiteByUuid",
+  "getSiteCounts",
+  "getSiteMenu",
+  "getSitePages",
+  "getSiteRenderedMenu",
+  "getSiteRenderedPage",
+  "getSites",
+  "getSlackApp",
+  "getSlackAppAccounts",
+  "getSlackApps",
+  "getSlackInstallations",
+  "getSlackThreads",
+  "getSnippet",
+  "getStepMemberCounts",
+  "getStepMembers",
+  "getSupervisor",
+  "getSupervisors",
+  "getSyncRunItems",
+  "getSyncRuns",
+  "getTask",
+  "getTaskChats",
+  "getTasks",
+  "getTeamsApp",
+  "getTeamsAppAccounts",
+  "getTeamsApps",
+  "getTeamsConversations",
+  "getTeamsInstallations",
+  "getTemplateContext",
+  "getTestChatRun",
+  "getThreadEmails",
+  "getTool",
+  "getToolCallNames",
+  "getToolkits",
+  "getUnreadNotificationCount",
+  "getUsageDashboard",
+  "getVariableRegistry",
+  "getVoiceToken",
+  "getVoiceUsageReport",
+  "getWebhookLogs",
+  "getWorkflow",
+  "getWorkflowAccessValidation",
+  "getWorkflowActivity",
+  "getWorkflowConfigValidation",
+  "getWorkflowContributors",
+  "getWorkflowDeletionPreview",
+  "getWorkflowDiagram",
+  "getWorkflowNotes",
+  "getWorkflowRouteDryRun",
+  "getWorkflowTaskAssignmentStats",
+  "getWorkflowTemplates",
+  "getWorkflowThumbnailUrl",
+  "getWorkflowVersion",
+  "getWorkflowVersionActive",
+  "getWorkflowVersions",
+  "getWorkflows",
+  "getWorkflowsActivityBatch",
+  "getWorkspace",
+  "getWorkspaceBuilder",
+  "getWorkspaceBuilders",
+  "getWorkspaceCounts",
+  "getWorkspaceDefaults",
+  "getWorkspaceEmailDomains",
+  "getWorkspaceMember",
+  "getWorkspaceMembers",
+  "getWorkspaceNotices",
+  "getWorkspaceProduct",
+  "getWorkspaceSiteDomains",
+  "getWorkspaceSubscriptions",
+  "getWorkspaceSupportRequest",
+  "getWorkspaceThemes",
+  "importFromBoard",
+  "importHubspotMembers",
+  "importMembers",
+  "importSalesforceMembers",
+  "importWorkspace",
+  "initiateCall",
+  "initiateOutboundCall",
+  "inspectPrompt",
+  "inviteMemberCredentialUpdate",
+  "inviteToWorkspace",
+  "leaveWorkspace",
+  "linkCalendarToGoogle",
+  "linkCalendarToHealthie",
+  "linkMemberToHealthie",
+  "linkMemberToHubspot",
+  "linkMemberToMonday",
+  "linkMemberToSalesforce",
+  "linkPhoneNumber",
+  "listAppConnections",
+  "listAvailableAppConnections",
+  "listConfluencePages",
+  "listConfluenceSpaces",
+  "listConnectionMemberFieldKeys",
+  "listGoogleCalendars",
+  "listHealthieAppointmentTypes",
+  "listHealthiePatients",
+  "listHealthieProviders",
+  "listPersonas",
+  "listPushSubscriptions",
+  "listScenarios",
+  "listSnippets",
+  "listTestChatRuns",
+  "listWorkspaceInvitationsAdmin",
+  "listWorkspaceSupportRequests",
+  "markEmailAsRead",
+  "markEmailAsUnread",
+  "markNotificationAsRead",
+  "previewImportWorkspace",
+  "previewSchedule",
+  "previewTTS",
+  "previewTemplate",
+  "previewThinkingSound",
+  "previewWorkspaceImport",
+  "provisionClientWorkspace",
+  "publishWorkflowVersion",
+  "rateMessage",
+  "reenrollMember",
+  "registerLinkedRolesMetadata",
+  "registerPushSubscription",
+  "registerSlashCommands",
+  "reindexFolder",
+  "releasePhoneNumber",
+  "removeFileRole",
+  "removeFolderRole",
+  "removeGroupMember",
+  "reorderEventRules",
+  "reorderMenuItems",
+  "replyToEmail",
+  "requestPhoneNumber",
+  "requestWorkspaceMembership",
+  "resetRoutineRuns",
+  "resolveAccessGrant",
+  "resolveAgentTools",
+  "resolveAnonymousMember",
+  "revokeAccessGrant",
+  "revokeApiKey",
+  "revokeICalToken",
+  "runRoutine",
+  "searchEventRules",
+  "searchFolder",
+  "searchHubspotRecords",
+  "searchSalesforceRecords",
+  "selectCurrentAssignmentTask",
+  "sendAssistantMessage",
+  "sendChatMessage",
+  "sendOperatorMessage",
+  "siteGoogleOAuthInitiate",
+  "siteSendEmailCode",
+  "siteSendPhoneCode",
+  "siteSignup",
+  "siteVerifyCode",
+  "skipStep",
+  "startConfluenceOAuth",
+  "startHubspotOAuth",
+  "startSalesforceOAuth",
+  "startSyncRun",
+  "startTestChatRun",
+  "summarizeChat",
+  "switchMember",
+  "syncCalendarWithGoogle",
+  "syncCalendarWithHealthie",
+  "testFhirConnection",
+  "testMcpServerConnection",
+  "testMondayConnection",
+  "testRunJourney",
+  "toggleFieldIndex",
+  "unarchiveAgent",
+  "unarchiveChat",
+  "unarchiveDataType",
+  "unarchiveMember",
+  "unarchiveTask",
+  "unarchiveWorkflow",
+  "unenrollMembers",
+  "unlinkCalendarFromGoogle",
+  "unlinkCalendarFromHealthie",
+  "unlinkCredential",
+  "unlinkMemberFromHealthie",
+  "unlinkMemberFromHubspot",
+  "unlinkMemberFromMonday",
+  "unlinkMemberFromSalesforce",
+  "unregisterPushSubscription",
+  "updateAgent",
+  "updateAssignment",
+  "updateCalendar",
+  "updateCalendarEvent",
+  "updateCalendarSchedule",
+  "updateChat",
+  "updateChatFilter",
+  "updateChatLabel",
+  "updateChatMute",
+  "updateChatNeedsResponse",
+  "updateClientWorkspace",
+  "updateConnection",
+  "updateConnectionSyncConfig",
+  "updateCurrentMember",
+  "updateCustomTool",
+  "updateCustomToolkit",
+  "updateDataRecord",
+  "updateDataType",
+  "updateDiscordBot",
+  "updateEventAttendee",
+  "updateEventRule",
+  "updateEventType",
+  "updateExperiment",
+  "updateExperimentAssignment",
+  "updateExperimentGroup",
+  "updateFhirConnection",
+  "updateFile",
+  "updateFileLabel",
+  "updateFileRoles",
+  "updateFileSharing",
+  "updateFirstRunState",
+  "updateFolder",
+  "updateFolderRoles",
+  "updateFolderSharing",
+  "updateGoal",
+  "updateInbox",
+  "updateJourney",
+  "updateJourneyNote",
+  "updateMcpServer",
+  "updateMember",
+  "updateMemberField",
+  "updateMemberFilter",
+  "updateMemberLabel",
+  "updateMemberRole",
+  "updateMenuItem",
+  "updateMilestone",
+  "updateMondaySyncConfig",
+  "updateNotificationRule",
+  "updateOperatorGroup",
+  "updatePage",
+  "updatePersona",
+  "updatePhoneNumber",
+  "updatePlatformApp",
+  "updateProduct",
+  "updateRoutine",
+  "updateSalesforceSyncConfig",
+  "updateScenario",
+  "updateSite",
+  "updateSlackApp",
+  "updateSnippet",
+  "updateStep",
+  "updateSupervisor",
+  "updateTask",
+  "updateTeamsApp",
+  "uploadFile",
+  "updateVoicemailStatus",
+  "updateWorkflow",
+  "updateWorkflowContributor",
+  "updateWorkflowNote",
+  "updateWorkflowVersion",
+  "updateWorkspace",
+  "updateWorkspaceDefaults",
+  "updateWorkspaceInvitationAdmin",
+  "updateWorkspaceThemes",
+  "upsertDataRecord",
+  "validateDataTypeSlug",
+  "validateWorkflowName"
+];
+var WORKSPACE_METHOD_NAME_SET = new Set(WORKSPACE_METHOD_NAMES);
+function createWorkspaceClient(root, workspaceUuid) {
+  return new Proxy(
+    { root, workspaceUuid },
+    {
+      get(target, prop, receiver) {
+        if (prop in target) return Reflect.get(target, prop, receiver);
+        if (typeof prop !== "string" || !WORKSPACE_METHOD_NAME_SET.has(prop)) {
+          return void 0;
+        }
+        const value = root[prop];
+        if (typeof value !== "function") return void 0;
+        return (...args) => value.call(root, workspaceUuid, ...args);
+      }
+    }
+  );
+}
+
 // src/client/bindings/access-grants.ts
 function bindAccessGrantsMethods(target, accessGrants) {
   target.getMyReceivedGrants = accessGrants.getMyReceivedGrants.bind(accessGrants);
@@ -8121,6 +8959,7 @@ function bindAgentsMethods(target, agents) {
   target.deleteAgent = agents.deleteAgent.bind(agents);
   target.archiveAgent = agents.archiveAgent.bind(agents);
   target.unarchiveAgent = agents.unarchiveAgent.bind(agents);
+  target.resolveAgentTools = agents.resolveAgentTools.bind(agents);
 }
 
 // src/client/bindings/tasks.ts
@@ -8185,6 +9024,7 @@ function bindChatsMethods(target, chats) {
 
 // src/client/bindings/calls.ts
 function bindCallsMethods(target, calls, cel) {
+  target.getPhoneCalls = calls.getPhoneCalls.bind(calls);
   target.initiateCall = calls.initiateCall.bind(calls);
   target.getVoiceToken = calls.getVoiceToken.bind(calls);
   target.getMessageTiming = calls.getMessageTiming.bind(calls);
@@ -8195,6 +9035,7 @@ function bindCallsMethods(target, calls, cel) {
 function bindDataTypesMethods(target, dataTypes) {
   target.getDataTypes = dataTypes.getDataTypes.bind(dataTypes);
   target.getDataType = dataTypes.getDataType.bind(dataTypes);
+  target.getDataTypeByUuid = dataTypes.getDataTypeByUuid.bind(dataTypes);
   target.getDataTypeBySlug = dataTypes.getDataTypeBySlug.bind(dataTypes);
   target.createDataType = dataTypes.createDataType.bind(dataTypes);
   target.updateDataType = dataTypes.updateDataType.bind(dataTypes);
@@ -8431,6 +9272,7 @@ function bindFilesMethods(target, files) {
   target.getFiles = files.getFiles.bind(files);
   target.getFile = files.getFile.bind(files);
   target.createFile = files.createFile.bind(files);
+  target.uploadFile = files.uploadFile.bind(files);
   target.updateFile = files.updateFile.bind(files);
   target.deleteFile = files.deleteFile.bind(files);
   target.convertFile = files.convertFile.bind(files);
@@ -8961,6 +9803,10 @@ function bindJourneysMethods(target, journeys) {
   target.reenrollMember = journeys.reenrollMember.bind(journeys);
   target.deleteEnrollment = journeys.deleteEnrollment.bind(journeys);
   target.getMemberJourneys = journeys.getMemberJourneys.bind(journeys);
+  target.getStepMembers = journeys.getStepMembers.bind(journeys);
+  target.getStepMemberCounts = journeys.getStepMemberCounts.bind(journeys);
+  target.advanceStep = journeys.advanceStep.bind(journeys);
+  target.skipStep = journeys.skipStep.bind(journeys);
   target.testRunJourney = journeys.testRunJourney.bind(journeys);
   target.getJourneyNotes = journeys.getJourneyNotes.bind(journeys);
   target.createJourneyNote = journeys.createJourneyNote.bind(journeys);
@@ -9104,6 +9950,7 @@ var GravityRailClient = class {
   deleteChatFilter;
   getChatFilterCount;
   // Calls API
+  getPhoneCalls;
   initiateCall;
   getVoiceToken;
   getMessageTiming;
@@ -9111,6 +9958,7 @@ var GravityRailClient = class {
   // Data Types API
   getDataTypes;
   getDataType;
+  getDataTypeByUuid;
   getDataTypeBySlug;
   createDataType;
   updateDataType;
@@ -9195,6 +10043,7 @@ var GravityRailClient = class {
   deleteAgent;
   archiveAgent;
   unarchiveAgent;
+  resolveAgentTools;
   // Qualifications API
   getQualifications;
   getQualification;
@@ -9237,6 +10086,10 @@ var GravityRailClient = class {
   reenrollMember;
   deleteEnrollment;
   getMemberJourneys;
+  getStepMembers;
+  getStepMemberCounts;
+  advanceStep;
+  skipStep;
   testRunJourney;
   getJourneyNotes;
   createJourneyNote;
@@ -9452,6 +10305,7 @@ var GravityRailClient = class {
   getFiles;
   getFile;
   createFile;
+  uploadFile;
   updateFile;
   deleteFile;
   convertFile;
@@ -9987,6 +10841,20 @@ var GravityRailClient = class {
     bindResellersMethods(this, apis.resellers);
     bindSupportRequestMethods(this, apis.supportRequests);
   }
+  /**
+   * Return a workspace-scoped client facade.
+   *
+   * Methods on the returned client are the same public SDK methods, but with
+   * the workspace UUID pre-bound:
+   *
+   * ```ts
+   * const workspace = client.workspace("workspace-uuid");
+   * await workspace.getAccessGrants({ status: "approved" });
+   * ```
+   */
+  workspace(workspaceUuid) {
+    return createWorkspaceClient(this, workspaceUuid);
+  }
   /**
    * Set the handler for enhanced authentication requirements (RFC 9470 Step-Up Auth).
    * This handler is called when a 401 response includes WWW-Authenticate header
@@ -10070,6 +10938,1212 @@ var GravityRailClient = class {
   }
 };
 
+// src/workspace-builder/resource.ts
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+  if (!isRecord(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function slugify(name) {
+  return name.toLowerCase().replaceAll(" ", "_").replaceAll("-", "_");
+}
+var WorkspaceBuilderResource = class {
+  _id;
+  _uuid;
+  _created = false;
+  _existed = false;
+  matchKey() {
+    return void 0;
+  }
+  adopt(existing) {
+    this._id = existing.id;
+    this._uuid = existing.uuid;
+    this._existed = true;
+  }
+};
+function resolveRefs(params) {
+  return resolveRefValue(params);
+}
+function resolveRefValue(value) {
+  if (value instanceof WorkspaceBuilderResource) return value._uuid;
+  if (Array.isArray(value)) return value.map(resolveRefValue);
+  if (!isPlainRecord(value)) return value;
+  const out = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    out[key] = resolveRefValue(nestedValue);
+  }
+  return out;
+}
+
+// src/workspace-builder/automation.ts
+var MemberFilterBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+  }
+  description;
+  rules = [];
+  addRule(objectType, filterType, options = {}) {
+    this.rules.push({
+      objectType,
+      filterType,
+      ...options.objectIds ? { objectIds: options.objectIds } : {},
+      ...options.query ? { query: options.query } : {}
+    });
+    return this;
+  }
+  planLine() {
+    return `MemberFilter: ${this.name}${this.rules.length ? ` (${this.rules.length} rules)` : ""}`;
+  }
+  async apply(client) {
+    const payload = {
+      name: this.name,
+      description: this.description,
+      rules: this.rules
+    };
+    const result = await client.createMemberFilter(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var RoutineBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, cronSchedule = "", options = {}) {
+    super();
+    this.name = name;
+    this.cronSchedule = cronSchedule;
+    this.active = options.active ?? false;
+    this.description = options.description ?? "";
+  }
+  active;
+  description;
+  rules = [];
+  addRule(actionType, options = {}) {
+    this.rules.push({
+      actionType,
+      workflow: options.workflow,
+      memberFilter: options.memberFilter,
+      actionParams: options.actionParams ?? {}
+    });
+    return this;
+  }
+  planLine() {
+    const parts = [
+      ...this.cronSchedule ? [`cron=${this.cronSchedule}`] : [],
+      ...this.rules.length ? [`${this.rules.length} rules`] : [],
+      this.active ? "active" : "inactive"
+    ];
+    return `Routine: ${this.name} (${parts.join(", ")})`;
+  }
+  async apply(client) {
+    const eventRules = this.rules.map((rule) => {
+      const actionParams = { ...rule.actionParams };
+      if (rule.workflow?._id !== void 0) actionParams.workflowId = rule.workflow._id;
+      if (rule.memberFilter?._id !== void 0)
+        actionParams.memberFilterId = rule.memberFilter._id;
+      return {
+        uuid: crypto.randomUUID(),
+        objectType: "routine" /* ROUTINE */,
+        eventType: "routine:triggered" /* ROUTINE_TRIGGERED */,
+        actionType: rule.actionType,
+        actionParams,
+        active: true
+      };
+    });
+    const payload = {
+      name: this.name,
+      cronString: this.cronSchedule,
+      scheduleMode: this.cronSchedule ? "CRON" : void 0,
+      scheduleEnabled: this.active,
+      ...this.description ? { description: this.description } : {},
+      ...eventRules.length ? { eventRules } : {}
+    };
+    const result = await client.createRoutine(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var NotificationRuleBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.noticeType = options.noticeType ?? options.notice_type ?? name;
+    this.memberId = options.memberId ?? options.member_id;
+    this.workflow = options.workflow;
+    this.prompt = options.prompt ?? options.message;
+    this.notifySms = Boolean(options.notifySms ?? options.notify_sms);
+    this.notifyEmail = Boolean(options.notifyEmail ?? options.notify_email);
+    this.notifyVoice = Boolean(options.notifyVoice ?? options.notify_voice);
+  }
+  noticeType;
+  memberId;
+  workflow;
+  prompt;
+  notifySms;
+  notifyEmail;
+  notifyVoice;
+  planLine() {
+    const parts = [];
+    if (this.memberId !== void 0) parts.push(`memberId=${this.memberId}`);
+    if (this.workflow) parts.push(`workflow='${this.workflow.name}'`);
+    return `NotificationRule: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    if (this.memberId === void 0) {
+      throw new Error(`Notification rule '${this.name}' requires memberId`);
+    }
+    const payload = {
+      noticeType: this.noticeType,
+      memberId: this.memberId,
+      workflowId: this.workflow?._id,
+      prompt: this.prompt ?? null,
+      notifySms: this.notifySms,
+      notifyEmail: this.notifyEmail,
+      notifyVoice: this.notifyVoice
+    };
+    const result = await client.createNotificationRule(payload);
+    this._id = result.id;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/forms.ts
+function normalizeOptions(options) {
+  if (options.length === 0) return [];
+  const first = options[0];
+  if (isRecord(first)) return options;
+  if (Array.isArray(first)) {
+    return options.map((entry) => ({ label: String(entry[0]), value: entry[1] }));
+  }
+  return options.map((option) => ({ label: String(option), value: String(option) }));
+}
+function createFieldDraft(fieldType, name, slug, options = {}) {
+  return {
+    name,
+    slug,
+    fieldType,
+    required: Boolean(options.required),
+    order: options.order ?? 0,
+    ...options.description ? { description: options.description } : {},
+    ...options.choices ? { options: options.choices } : {},
+    ...options.cel ? { celFunction: options.cel } : {}
+  };
+}
+var FormBuilder = class extends WorkspaceBuilderResource {
+  name;
+  slug;
+  description;
+  prompt;
+  collection;
+  fields = [];
+  eventRules = [];
+  constructor(name, slug, options = {}) {
+    super();
+    this.name = name;
+    this.slug = slug ?? slugify(name);
+    this.description = options.description ?? "";
+    this.prompt = options.prompt ?? "";
+    this.collection = options.collection ?? false;
+    for (const field of options.fields ?? []) {
+      if (!isRecord(field) || !field.name) continue;
+      const choices = field.options ? normalizeOptions(field.options) : void 0;
+      this.fields.push(
+        createFieldDraft(
+          field.fieldType ?? field.field_type ?? "text" /* TEXT */,
+          field.name,
+          field.slug ?? slugify(field.name),
+          {
+            required: Boolean(field.required ?? field.isRequired),
+            order: field.order ?? 0,
+            description: field.description,
+            choices
+          }
+        )
+      );
+    }
+  }
+  field(fieldType, name, slug, options = {}) {
+    this.fields.push(createFieldDraft(fieldType, name, slug, options));
+    return this;
+  }
+  enumField(name, slug, options, settings = {}) {
+    return this.field("enum" /* ENUM */, name, slug, {
+      ...settings,
+      choices: normalizeOptions(options)
+    });
+  }
+  textField(name, slug, settings = {}) {
+    return this.field("text" /* TEXT */, name, slug, settings);
+  }
+  numberField(name, slug, settings = {}) {
+    return this.field("number" /* NUMBER */, name, slug, settings);
+  }
+  dateField(name, slug, settings = {}) {
+    return this.field("date" /* DATE */, name, slug, settings);
+  }
+  booleanField(name, slug, settings = {}) {
+    return this.field("boolean" /* BOOLEAN */, name, slug, settings);
+  }
+  functionField(name, slug, cel, settings = {}) {
+    return this.field("function" /* FUNCTION */, name, slug, { ...settings, cel });
+  }
+  emailField(name, slug, settings = {}) {
+    return this.field("email" /* EMAIL */, name, slug, settings);
+  }
+  phoneField(name, slug, settings = {}) {
+    return this.field("phone" /* PHONE */, name, slug, settings);
+  }
+  longtextField(name, slug, settings = {}) {
+    return this.field("longtext" /* LONGTEXT */, name, slug, settings);
+  }
+  integerField(name, slug, settings = {}) {
+    return this.field("integer" /* INTEGER */, name, slug, settings);
+  }
+  datetimeField(name, slug, settings = {}) {
+    return this.field("datetime" /* DATETIME */, name, slug, settings);
+  }
+  timeOfDayField(name, slug, settings = {}) {
+    return this.field("time_of_day" /* TIME_OF_DAY */, name, slug, settings);
+  }
+  usZipCodeField(name, slug, settings = {}) {
+    return this.field("us_zip_code" /* US_ZIP_CODE */, name, slug, settings);
+  }
+  arrayField(name, slug, settings = {}) {
+    return this.field("array" /* ARRAY */, name, slug, settings);
+  }
+  objectField(name, slug, settings = {}) {
+    return this.field("object" /* OBJECT */, name, slug, settings);
+  }
+  onRecordCreated(action, params = {}, condition, name) {
+    this.eventRules.push({
+      eventType: "data_record:created" /* DATA_RECORD_CREATED */,
+      actionType: action,
+      actionParams: params,
+      condition,
+      name
+    });
+    return this;
+  }
+  onRecordUpdated(action, params = {}, condition, name) {
+    this.eventRules.push({
+      eventType: "data_record:updated" /* DATA_RECORD_UPDATED */,
+      actionType: action,
+      actionParams: params,
+      condition,
+      name
+    });
+    return this;
+  }
+  matchKey() {
+    return this.slug;
+  }
+  planLine() {
+    return `Form: ${this.name} (slug=${this.slug}, ${this.fields.length} fields)`;
+  }
+  async apply(client) {
+    if (this._existed) return;
+    const payload = {
+      name: this.name,
+      slug: this.slug,
+      description: this.description,
+      prompt: this.prompt,
+      isCollection: this.collection,
+      fields: this.fields
+    };
+    const result = await client.createDataType(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var MemberLabelBuilder = class extends WorkspaceBuilderResource {
+  name;
+  slug;
+  color;
+  description;
+  constructor(name, slug, color = "8b5cf6", description = "") {
+    super();
+    this.name = name;
+    this.slug = slug ?? slugify(name);
+    this.color = color;
+    this.description = description;
+  }
+  matchKey() {
+    return this.slug;
+  }
+  planLine() {
+    return `Label: ${this.name} (slug=${this.slug})`;
+  }
+  async apply(client) {
+    if (this._existed) return;
+    const payload = {
+      name: this.name,
+      slug: this.slug,
+      color: this.color,
+      description: this.description
+    };
+    const result = await client.createMemberLabel(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/journeys.ts
+var JourneyStepBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, journey, order = 0, workflow, description = "") {
+    super();
+    this.name = name;
+    this.journey = journey;
+    this.order = order;
+    this.workflow = workflow;
+    this.description = description;
+  }
+  connections = [];
+  connectsTo(child, condition, required = false, timeoutSeconds) {
+    this.connections.push({ parent: this, child, condition, required, timeoutSeconds });
+    return this;
+  }
+  planLine() {
+    return `Step: ${this.name}${this.workflow ? ` -> workflow '${this.workflow.name}'` : ""}`;
+  }
+  async apply(client) {
+    if (this.journey._id === void 0) return;
+    const payload = {
+      name: this.name,
+      description: this.description,
+      order: this.order,
+      ...this.workflow?._id ? { workflowId: this.workflow._id } : {}
+    };
+    const result = await client.createStep(this.journey._id, payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var JourneyBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+  }
+  description;
+  steps = [];
+  goals = [];
+  step(name, options = {}) {
+    const step = new JourneyStepBuilder(
+      name,
+      this,
+      options.order ?? 0,
+      options.workflow,
+      options.description ?? ""
+    );
+    this.steps.push(step);
+    return step;
+  }
+  goal(name, options = {}) {
+    this.goals.push({
+      name,
+      description: options.description ?? "",
+      step: options.step,
+      completionCel: options.completionCel ?? options.completion_cel,
+      value: options.value,
+      order: options.order ?? 0
+    });
+    return this;
+  }
+  planLine() {
+    const parts = [];
+    if (this.steps.length) parts.push(`${this.steps.length} steps`);
+    if (this.goals.length) parts.push(`${this.goals.length} goals`);
+    return `Journey: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    const result = await client.createJourney({
+      name: this.name,
+      description: this.description
+    });
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+function buildJourneyConnectionPayload(connection) {
+  if (!connection.parent._uuid || !connection.child._uuid) return void 0;
+  return {
+    parentStepUuid: connection.parent._uuid,
+    childStepUuid: connection.child._uuid,
+    ...connection.condition ? { celCondition: connection.condition } : {},
+    ...connection.required ? { required: true } : {},
+    ...connection.timeoutSeconds ? { timeoutSeconds: connection.timeoutSeconds } : {}
+  };
+}
+function buildJourneyGoalPayload(goal) {
+  return {
+    name: goal.name,
+    description: goal.description,
+    order: goal.order,
+    ...goal.step?._uuid ? { goalStepUuid: goal.step._uuid } : {},
+    ...goal.completionCel ? { completionCel: goal.completionCel } : {},
+    ...goal.value !== void 0 ? { value: goal.value } : {}
+  };
+}
+
+// src/workspace-builder/role-update.ts
+var RoleUpdate = class extends WorkspaceBuilderResource {
+  constructor(roleId, workflowIds, dataTypeIds) {
+    super();
+    this.roleId = roleId;
+    this.workflowIds = workflowIds;
+    this.dataTypeIds = dataTypeIds;
+  }
+  planLine() {
+    const parts = [];
+    if (this.workflowIds) parts.push(`workflows=${JSON.stringify(this.workflowIds)}`);
+    if (this.dataTypeIds) parts.push(`dataTypes=${JSON.stringify(this.dataTypeIds)}`);
+    return `RoleUpdate: roleId=${this.roleId}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    const payload = {};
+    if (this.workflowIds) payload.workflowIds = this.workflowIds;
+    if (this.dataTypeIds) payload.dataTypeIds = this.dataTypeIds;
+    if (Object.keys(payload).length) await client.updateMemberRole(this.roleId, payload);
+    this._id = this.roleId;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/workflows.ts
+var PERM_KEYS = {
+  canRead: "canRead",
+  canCreate: "canCreate",
+  canEdit: "canEdit",
+  can_read: "canRead",
+  can_create: "canCreate",
+  can_edit: "canEdit"
+};
+var ABILITY_TYPE_MAP = {
+  data_access: "integration:data_access",
+  file_access: "integration:file_access",
+  escalation: "oversight:escalation"
+};
+var AbilityDef = class {
+  constructor(abilityType, options = {}) {
+    this.abilityType = abilityType;
+    this.config = options.config ?? {};
+    this.enabled = options.enabled ?? true;
+    this.celCondition = options.celCondition ?? options.cel_condition;
+    this.form = options.form;
+    for (const [inputKey, outputKey] of Object.entries(PERM_KEYS)) {
+      if (inputKey in options) this.perms[outputKey] = options[inputKey];
+    }
+  }
+  uuid = crypto.randomUUID();
+  config;
+  enabled;
+  celCondition;
+  form;
+  perms = {};
+  toAbility() {
+    const config = { ...this.config };
+    if (this.form?._uuid) {
+      config.dataTypeUuid = this.form._uuid;
+      Object.assign(config, this.perms);
+    }
+    return {
+      uuid: this.uuid,
+      abilityType: ABILITY_TYPE_MAP[this.abilityType] ?? this.abilityType,
+      config,
+      enabled: this.enabled,
+      ...this.celCondition ? { celCondition: this.celCondition } : {}
+    };
+  }
+};
+var TaskBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, workflow, prompt = "", start = false, description = "") {
+    super();
+    this.name = name;
+    this.workflow = workflow;
+    this.prompt = prompt;
+    this.start = start;
+    this.description = description;
+  }
+  transitions = [];
+  eventRules = [];
+  transitionsTo(child, when, autoNext = false, required = false) {
+    if (child === this) {
+      throw new Error(`Task '${this.name}' cannot transition to itself`);
+    }
+    this.transitions.push({ parent: this, child, when, autoNext, required });
+    return this;
+  }
+  onEnter(action, params = {}, name) {
+    this.eventRules.push({
+      eventType: "task:execute" /* TASK_EXECUTE */,
+      actionType: action,
+      actionParams: params,
+      name
+    });
+    return this;
+  }
+  initialMessage(message, suggestions) {
+    return this.onEnter("assistant:message", {
+      message,
+      ...suggestions ? { suggestions } : {}
+    });
+  }
+  planLine() {
+    return `Task: ${this.name}${this.start ? " [start]" : ""}`;
+  }
+  async apply(client) {
+    if (this._existed || this.workflow._id === void 0) return;
+    const result = await client.createTask({
+      workflowId: this.workflow._id,
+      name: this.name,
+      prompt: this.prompt,
+      description: this.description
+    });
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var WorkflowBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.description = options.description ?? "";
+    this.prompt = options.prompt;
+    this.agentId = options.agentId ?? options.agent_id;
+  }
+  description;
+  prompt;
+  agentId;
+  tasks = [];
+  abilities = [];
+  task(name, options = {}) {
+    const task = new TaskBuilder(
+      name,
+      this,
+      options.prompt ?? "",
+      options.start ?? false,
+      options.description ?? ""
+    );
+    this.tasks.push(task);
+    return task;
+  }
+  ability(abilityType, options = {}) {
+    this.abilities.push(new AbilityDef(abilityType, options));
+    return this;
+  }
+  get startTask() {
+    return this.tasks.find((task) => task.start) ?? this.tasks[0];
+  }
+  matchKey() {
+    return this.name;
+  }
+  adopt(existing) {
+    super.adopt(existing);
+    const start = this.startTask;
+    if (start && existing.startTaskId) {
+      start._id = existing.startTaskId;
+      start._existed = true;
+    }
+  }
+  planLine() {
+    const details = [];
+    if (this.tasks.length) details.push(`${this.tasks.length} tasks`);
+    if (this.abilities.length) details.push(`${this.abilities.length} abilities`);
+    return `Workflow: ${this.name}${details.length ? ` (${details.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    if (this._existed) return;
+    const payload = {
+      name: this.name,
+      description: this.description,
+      createMode: "taskless",
+      ...this.prompt ? { prompt: this.prompt } : {},
+      ...this.agentId ? { agentId: this.agentId } : {},
+      ...this.abilities.length ? { abilities: this.abilities.map((ability) => ability.toAbility()) } : {}
+    };
+    const result = await client.createWorkflow(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+var AgentBuilder = class extends WorkspaceBuilderResource {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.chatModelId = options.chatModelId ?? options.chat_model_id ?? "";
+    this.systemPrompt = options.systemPrompt ?? options.system_prompt ?? "";
+    this.memberRoleId = options.roleId ?? options.role_id;
+    this.tools = options.tools ?? [];
+    this.codeInterpreterEnabled = options.codeInterpreterEnabled ?? options.code_interpreter_enabled ?? false;
+  }
+  chatModelId;
+  systemPrompt;
+  memberRoleId;
+  tools;
+  codeInterpreterEnabled;
+  planLine() {
+    const parts = [];
+    if (this.chatModelId) parts.push(`model=${this.chatModelId}`);
+    if (this.tools.length) parts.push(`${this.tools.length} tools`);
+    return `Agent: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+  }
+  async apply(client) {
+    if (this.memberRoleId === void 0) {
+      throw new Error(`Agent '${this.name}' requires memberRoleId`);
+    }
+    if (!this.chatModelId) {
+      throw new Error(`Agent '${this.name}' requires chatModelId`);
+    }
+    const payload = {
+      name: this.name,
+      memberRoleId: this.memberRoleId,
+      chatModelId: this.chatModelId,
+      systemPrompt: this.systemPrompt,
+      ...this.tools.length ? { tools: this.tools } : {},
+      ...this.codeInterpreterEnabled ? { codeInterpreterEnabled: true } : {}
+    };
+    const result = await client.createAgent(payload);
+    this._id = result.id;
+    this._uuid = result.uuid;
+    this._created = true;
+  }
+};
+
+// src/workspace-builder/orchestrator.ts
+var PHASES = /* @__PURE__ */ new Map([
+  [FormBuilder, 0],
+  [MemberLabelBuilder, 0],
+  [AgentBuilder, 1],
+  [WorkflowBuilder, 2],
+  [TaskBuilder, 3],
+  [RoleUpdate, 4],
+  [MemberFilterBuilder, 5],
+  [RoutineBuilder, 6],
+  [NotificationRuleBuilder, 6],
+  [JourneyBuilder, 7],
+  [JourneyStepBuilder, 8]
+]);
+var WorkspaceBuilder = class {
+  constructor(client) {
+    this.client = client;
+  }
+  resources = [];
+  form(name, options = {}) {
+    const form = new FormBuilder(name, options.slug, options);
+    this.resources.push(form);
+    return form;
+  }
+  workflow(name, options = {}) {
+    const workflow = new WorkflowBuilder(name, options);
+    this.resources.push(workflow);
+    return workflow;
+  }
+  label(name, options = {}) {
+    const label = new MemberLabelBuilder(
+      name,
+      options.slug,
+      options.color,
+      options.description ?? ""
+    );
+    this.resources.push(label);
+    return label;
+  }
+  journey(name, options = {}) {
+    const journey = new JourneyBuilder(name, options);
+    this.resources.push(journey);
+    return journey;
+  }
+  agent(name, options = {}) {
+    const agent = new AgentBuilder(name, options);
+    this.resources.push(agent);
+    return agent;
+  }
+  routine(name, cronSchedule = "", options = {}) {
+    const routine = new RoutineBuilder(name, cronSchedule, options);
+    this.resources.push(routine);
+    return routine;
+  }
+  memberFilter(name, options = {}) {
+    const filter = new MemberFilterBuilder(name, options);
+    this.resources.push(filter);
+    return filter;
+  }
+  notificationRule(name, options = {}) {
+    const rule = new NotificationRuleBuilder(name, options);
+    this.resources.push(rule);
+    return rule;
+  }
+  roleUpdate(roleId, workflowIds, dataTypeIds) {
+    const update = new RoleUpdate(roleId, workflowIds, dataTypeIds);
+    this.resources.push(update);
+    return update;
+  }
+  plan() {
+    const resources = this.sortedResources();
+    writeLine(`
+${"=".repeat(50)}`);
+    writeLine("Plan");
+    writeLine("=".repeat(50));
+    for (const resource of resources) {
+      writeLine(`  + ${resource.planLine()}`);
+    }
+    const wiring = this.collectWiringSummary(resources);
+    if (wiring.length) {
+      writeLine("\n  Wiring:");
+      for (const line of wiring) writeLine(`    ${line}`);
+    }
+    writeLine(`
+  Total: ${resources.length} resources, ${wiring.length} connections`);
+    writeLine(`${"=".repeat(50)}
+`);
+  }
+  async preview() {
+    const resources = this.sortedResources();
+    await this.resolveExisting(resources);
+    writeLine(`
+${"=".repeat(50)}`);
+    writeLine("Preview");
+    writeLine("=".repeat(50));
+    for (const resource of resources) {
+      if (resource._existed) {
+        writeLine(`  = ${resource.planLine()} (exists, id=${resource._id})`);
+      } else {
+        writeLine(`  + ${resource.planLine()}`);
+      }
+    }
+    const wiring = this.collectWiringSummary(resources);
+    if (wiring.length) {
+      writeLine("\n  Wiring:");
+      for (const line of wiring) writeLine(`    ${line}`);
+    }
+    const toCreate = resources.filter((resource) => !resource._existed);
+    const existing = resources.filter((resource) => resource._existed);
+    writeLine(
+      `
+  Total: ${toCreate.length} to create, ${existing.length} existing, ${wiring.length} connections`
+    );
+    writeLine(`${"=".repeat(50)}
+`);
+  }
+  async apply() {
+    const resources = this.sortedResources();
+    await this.resolveExisting(resources);
+    const summary = {};
+    writeLine("Applying...");
+    for (const resource of resources) {
+      try {
+        if (resource._existed) {
+          const key = resourceKey(resource);
+          summary[key] ??= [];
+          summary[key].push(resource._id);
+          writeLine(`  Exists ${resource.planLine()} -> id=${resource._id}`);
+          continue;
+        }
+        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}`);
+        } else {
+          writeLine(`  Skipped: ${resource.planLine()}`);
+        }
+      } catch (err) {
+        writeLine(`  FAILED: ${resource.planLine()}: ${summarizeError(err)}`);
+        throw new ApplyError(resource, err, summary);
+      }
+    }
+    await this.applyTransitions();
+    await this.applyEventRules(resources);
+    await this.applyJourneyConnections(resources);
+    await this.applyJourneyGoals(resources);
+    const count = Object.values(summary).reduce((total, ids) => total + ids.length, 0);
+    writeLine(`
+Done! Created ${count} resources.`);
+    return summary;
+  }
+  async resolveExisting(resources) {
+    const formSlugs = new Map(
+      resources.filter((resource) => resource instanceof FormBuilder).map((resource) => [resource.slug, resource])
+    );
+    const labelSlugs = new Map(
+      resources.filter(
+        (resource) => resource instanceof MemberLabelBuilder
+      ).map((resource) => [resource.slug, resource])
+    );
+    const workflowNames = new Map(
+      resources.filter((resource) => resource instanceof WorkflowBuilder).map((resource) => [resource.name, resource])
+    );
+    if (formSlugs.size) {
+      for (const existing of await this.client.getDataTypes()) {
+        if (existing.slug && formSlugs.has(existing.slug)) {
+          formSlugs.get(existing.slug).adopt(existing);
+        }
+      }
+    }
+    if (labelSlugs.size) {
+      for (const existing of await this.client.getMemberLabels()) {
+        if (existing.slug && labelSlugs.has(existing.slug)) {
+          labelSlugs.get(existing.slug).adopt(existing);
+        }
+      }
+    }
+    if (!workflowNames.size) return;
+    for (const existing of await this.client.getWorkflows()) {
+      if (existing.name && workflowNames.has(existing.name)) {
+        workflowNames.get(existing.name).adopt(existing);
+      }
+    }
+    const adoptedWorkflows = resources.filter(
+      (resource) => resource instanceof WorkflowBuilder && resource._existed && resource._id !== void 0
+    );
+    if (!adoptedWorkflows.length) return;
+    const existingTasks = await this.client.getTasks();
+    for (const workflow of adoptedWorkflows) {
+      const workflowTasks = existingTasks.filter((task) => task.workflowId === workflow._id);
+      const taskByName = new Map(workflowTasks.map((task) => [task.name, task]));
+      for (const taskBuilder of workflow.tasks) {
+        const match = taskByName.get(taskBuilder.name);
+        if (match) taskBuilder.adopt(match);
+      }
+      const ids = /* @__PURE__ */ new Map();
+      for (const taskBuilder of workflow.tasks) {
+        if (taskBuilder._id !== void 0) {
+          ids.set(taskBuilder._id, [...ids.get(taskBuilder._id) ?? [], taskBuilder]);
+        }
+      }
+      for (const builders of ids.values()) {
+        if (builders.length <= 1) continue;
+        const nameAdopted = builders.filter((task) => taskByName.has(task.name));
+        for (const task of builders.filter((builder) => !nameAdopted.includes(builder))) {
+          task._id = void 0;
+          task._existed = false;
+        }
+      }
+    }
+  }
+  sortedResources() {
+    const all = [];
+    for (const resource of this.resources) {
+      all.push(resource);
+      if (resource instanceof WorkflowBuilder) {
+        const start = resource.startTask;
+        const tasks = start === void 0 ? resource.tasks : [start, ...resource.tasks.filter((task) => task !== start)];
+        all.push(...tasks);
+      } else if (resource instanceof JourneyBuilder) {
+        all.push(...resource.steps);
+      }
+    }
+    return all.sort(
+      (a, b) => (PHASES.get(a.constructor) ?? 99) - (PHASES.get(b.constructor) ?? 99)
+    );
+  }
+  collectWiringSummary(resources) {
+    const lines = [];
+    for (const resource of resources) {
+      if (resource instanceof TaskBuilder) {
+        for (const transition of resource.transitions) {
+          lines.push(`${transition.parent.name} -> ${transition.child.name}`);
+        }
+        for (const rule of resource.eventRules) {
+          lines.push(`${rule.actionType} on enter '${resource.name}'`);
+        }
+      } else if (resource instanceof FormBuilder) {
+        for (const rule of resource.eventRules) {
+          lines.push(`${rule.actionType} on ${rule.eventType} '${resource.name}'`);
+        }
+      } else if (resource instanceof RoutineBuilder) {
+        for (const rule of resource.rules)
+          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}`);
+        }
+      } else if (resource instanceof JourneyBuilder) {
+        for (const goal of resource.goals) lines.push(`Goal: ${goal.name}`);
+      }
+    }
+    return lines;
+  }
+  async applyTransitions() {
+    const parentChildren = /* @__PURE__ */ new Map();
+    for (const resource of this.sortedResources()) {
+      if (!(resource instanceof TaskBuilder)) continue;
+      for (const transition of resource.transitions) {
+        parentChildren.set(transition.parent, [
+          ...parentChildren.get(transition.parent) ?? [],
+          transition
+        ]);
+      }
+    }
+    for (const [parent, transitions] of parentChildren) {
+      if (parent._id === void 0) continue;
+      const childTasks = transitions.flatMap((transition) => {
+        const taskId = transition.child._id;
+        if (taskId === void 0 || taskId === parent._id) return [];
+        return [
+          {
+            taskId,
+            choicePrompt: transition.when,
+            celCondition: null,
+            autoNext: transition.autoNext,
+            required: transition.required
+          }
+        ];
+      });
+      if (!childTasks.length) continue;
+      await this.client.updateTask(parent._id, { childTasks });
+      writeLine(
+        `  Wired: ${parent.name} -> [${transitions.map((tr) => tr.child.name).join(", ")}]`
+      );
+    }
+  }
+  async applyEventRules(resources) {
+    for (const resource of resources) {
+      if (resource instanceof TaskBuilder) {
+        for (const rule of resource.eventRules) {
+          try {
+            const payload = {
+              objectType: "task" /* TASK */,
+              taskId: resource._id,
+              eventType: rule.eventType,
+              actionType: rule.actionType,
+              actionParams: resolveRefs(rule.actionParams),
+              ...rule.name ? { name: rule.name } : {}
+            };
+            await this.applyEventRule(
+              payload,
+              `${rule.actionType} on enter '${resource.name}'`
+            );
+          } catch (err) {
+            handleEventRuleApplyFailure(resource.name, err);
+          }
+        }
+      } else if (resource instanceof FormBuilder) {
+        for (const rule of resource.eventRules) {
+          try {
+            const payload = {
+              objectType: "data_record" /* DATA_RECORD */,
+              dataTypeId: resource._id,
+              eventType: rule.eventType,
+              actionType: rule.actionType,
+              actionParams: resolveRefs(rule.actionParams),
+              ...rule.condition ? { conditions: rule.condition } : {},
+              ...rule.name ? { name: rule.name } : {}
+            };
+            await this.applyEventRule(
+              payload,
+              `${rule.actionType} on ${rule.eventType} '${resource.name}'`
+            );
+          } catch (err) {
+            handleEventRuleApplyFailure(resource.name, err);
+          }
+        }
+      }
+    }
+  }
+  async applyEventRule(payload, label) {
+    const existing = await this.findMatchingEventRule(payload);
+    if (!existing) {
+      await this.client.createEventRule(payload);
+      writeLine(`  Wired: ${label}`);
+      return;
+    }
+    const update = eventRuleUpdate(existing, payload);
+    if (Object.keys(update).length) {
+      await this.client.updateEventRule(existing.id, update);
+      writeLine(`  Updated: ${label}`);
+    } else {
+      writeLine(`  Exists: ${label}`);
+    }
+  }
+  async findMatchingEventRule(payload) {
+    const sourceFilter = eventRuleSourceFilter(payload);
+    const candidates = await this.client.searchEventRules({
+      objectType: payload.objectType,
+      eventType: payload.eventType,
+      actionType: payload.actionType,
+      includeDisabled: true,
+      ...sourceFilter
+    });
+    return candidates.find((candidate) => eventRulesMatch(candidate, payload));
+  }
+  async applyJourneyConnections(resources) {
+    for (const resource of resources) {
+      if (!(resource instanceof JourneyStepBuilder)) continue;
+      for (const connection of resource.connections) {
+        if (resource.journey._id === void 0) continue;
+        const payload = buildJourneyConnectionPayload(connection);
+        if (!payload) continue;
+        await this.client.createConnection(resource.journey._id, payload);
+        writeLine(`  Wired: ${connection.parent.name} -> ${connection.child.name}`);
+      }
+    }
+  }
+  async applyJourneyGoals(resources) {
+    for (const resource of resources) {
+      if (!(resource instanceof JourneyBuilder) || resource._id === void 0) continue;
+      for (const goal of resource.goals) {
+        await this.client.createGoal(resource._id, buildJourneyGoalPayload(goal));
+        writeLine(`  Created goal: ${goal.name}`);
+      }
+    }
+  }
+};
+var ApplyError = class extends Error {
+  constructor(resource, cause, createdSoFar) {
+    super(
+      `Failed creating ${resource.planLine()}: ${summarizeError(cause)}
+Already created: ${JSON.stringify(
+        createdSoFar
+      )}`
+    );
+    this.resource = resource;
+    this.cause = cause;
+    this.createdSoFar = createdSoFar;
+  }
+};
+function resourceKey(resource) {
+  if (resource instanceof RoleUpdate) return "roleUpdates";
+  if (resource instanceof FormBuilder) return "forms";
+  if (resource instanceof MemberLabelBuilder) return "labels";
+  if (resource instanceof WorkflowBuilder) return "workflows";
+  if (resource instanceof TaskBuilder) return "tasks";
+  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 JourneyStepBuilder) return "journeySteps";
+  if (resource instanceof AgentBuilder) return "agents";
+  return "resources";
+}
+var SEARCHABLE_EVENT_RULE_SOURCE_FIELDS = [
+  "taskId",
+  "dataTypeId",
+  "routineId",
+  "workflowId",
+  "journeyStepId"
+];
+var EVENT_RULE_SOURCE_FIELDS = [
+  ...SEARCHABLE_EVENT_RULE_SOURCE_FIELDS,
+  "calendarId",
+  "calendarEventTypeId"
+];
+function eventRuleSourceFilter(payload) {
+  const filter = {};
+  for (const field of SEARCHABLE_EVENT_RULE_SOURCE_FIELDS) {
+    const value = payload[field];
+    if (value !== void 0 && value !== null) {
+      filter[field] = value;
+    }
+  }
+  return filter;
+}
+function eventRulesMatch(existing, payload) {
+  if (normalizeString(existing.name) !== normalizeString(payload.name)) return false;
+  if (existing.objectType !== payload.objectType) return false;
+  if (existing.eventType !== payload.eventType) return false;
+  if (existing.actionType !== payload.actionType) return false;
+  for (const field of EVENT_RULE_SOURCE_FIELDS) {
+    if ((existing[field] ?? null) !== (payload[field] ?? null)) return false;
+  }
+  if (normalizeString(payload.name)) return true;
+  if (normalizeString(existing.conditions) !== normalizeString(payload.conditions)) return false;
+  if (!eventRuleValueEqual(existing.actionParams, payload.actionParams ?? null)) return false;
+  if (!eventRuleValueEqual(existing.triggerParams, payload.triggerParams ?? null)) return false;
+  return true;
+}
+function eventRuleUpdate(existing, payload) {
+  const update = {};
+  const conditions = payload.conditions ?? null;
+  if (normalizeString(existing.conditions) !== normalizeString(conditions)) {
+    update.conditions = conditions;
+  }
+  const actionParams = payload.actionParams ?? null;
+  if (!eventRuleValueEqual(existing.actionParams, actionParams)) {
+    update.actionParams = payload.actionParams;
+  }
+  const triggerParams = payload.triggerParams ?? null;
+  if (!eventRuleValueEqual(existing.triggerParams, triggerParams)) {
+    update.triggerParams = payload.triggerParams;
+  }
+  const active = payload.active ?? true;
+  if (existing.active !== active) {
+    update.active = active;
+  }
+  const delay = payload.delay ?? 0;
+  if (existing.delay !== delay) {
+    update.delay = delay;
+  }
+  const order = payload.order ?? 0;
+  if (existing.order !== order) {
+    update.order = order;
+  }
+  return update;
+}
+function normalizeString(value) {
+  return value ?? "";
+}
+function eventRuleValueEqual(left, right) {
+  return JSON.stringify(stableValue(left)) === JSON.stringify(stableValue(right));
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== "object") return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, stableValue(nested)])
+  );
+}
+function writeLine(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+function handleEventRuleApplyFailure(resourceName, err) {
+  if (hasStatus(err, 403)) {
+    writeLine(
+      `  WARNING: Event rule on '${resourceName}' failed (retry exec() with scopes=['automations:admin'])`
+    );
+    return;
+  }
+  const summary = summarizeError(err);
+  writeLine(`  FAILED: Event rule on '${resourceName}': ${summary}`);
+  throw new Error(`Failed wiring event rule on '${resourceName}': ${summary}`);
+}
+function summarizeError(err) {
+  if (err instanceof Error) return err.name || "Error";
+  return typeof err;
+}
+function hasStatus(err, status) {
+  if (typeof err === "object" && err !== null) {
+    const candidate = err;
+    if (candidate.status === status || candidate.statusCode === status) return true;
+  }
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "";
+  return message.includes(String(status));
+}
+async function runWorkspaceScript(client, build, mode = "plan") {
+  const workspace = new WorkspaceBuilder(client);
+  await build(workspace);
+  if (mode === "plan") return workspace.plan();
+  if (mode === "preview") return workspace.preview();
+  if (mode === "apply") return workspace.apply();
+  throw new Error(`Unknown mode '${mode}'. Use plan, preview, or apply.`);
+}
+
 // src/types/ability-types.ts
 var AbilityTypeSlugs = {
   // Tools
@@ -11173,7 +13247,9 @@ var SCOPE_PRESETS = {
   AccessGrantStatus,
   AccessGrantTrigger,
   AccessLevel,
+  AgentBuilder,
   ApiError,
+  ApplyError,
   AppsApi,
   AttendeeResponseStatus,
   AttendeeStatus,
@@ -11210,19 +13286,25 @@ var SCOPE_PRESETS = {
   FhirClientType,
   FhirConnectionState,
   FhirVendor,
+  FormBuilder,
   GravityRailClient,
   IndexStatus,
   InvitationStatus,
   JobPosition,
+  JourneyBuilder,
+  JourneyStepBuilder,
   MASKED_SECRET_SENTINEL,
   McpServerState,
   MemberFeature,
+  MemberFilterBuilder,
+  MemberLabelBuilder,
   MemberType,
   MenuItemResponseItemType,
   MenuItemType,
   ModelProvider,
   ModelType,
   NO_ASSISTANT_PARTICIPANT_CHAT_TYPES,
+  NotificationRuleBuilder,
   OIDCAdminConfigViewProviderType,
   ORG_ONLY_RESOURCES,
   OrgApi,
@@ -11248,6 +13330,8 @@ var SCOPE_PRESETS = {
   Region,
   RegistrationIdentifier,
   Resource,
+  RoleUpdate,
+  RoutineBuilder,
   SCOPES,
   SCOPE_PRESETS,
   SMS_DELIVERY_FAILURE_STATUSES,
@@ -11267,15 +13351,19 @@ var SCOPE_PRESETS = {
   TTS_MODEL_ELEVENLABS_TURBO,
   TTS_MODEL_POCKET,
   TTS_PREVIEW_PROVIDERS,
+  TaskBuilder,
   TemplatesApi,
   ToolkitState,
   WorkflowAccessWarningResourceType,
+  WorkflowBuilder,
   WorkflowResourceType,
+  WorkspaceBuilder,
   WorkspaceFeature,
   WorkspaceProvisionStatus,
   areDependenciesSatisfied,
   canPreviewVoice,
   clearRegistry,
+  createWorkspaceClient,
   decodePermissions,
   encodePermissions,
   eventRuleActionParams,
@@ -11300,6 +13388,7 @@ var SCOPE_PRESETS = {
   isRegistryInitialized,
   isSMSDeliveryFailureStatus,
   requiresAssistantParticipant,
+  runWorkspaceScript,
   usesBuiltinAssistant,
   validateFeatureDependencies
 });