exponential-sdk 1.27.0 → 1.28.0

package/dist/index.js

@@ -233,10 +233,6 @@ var PageCommentsApi = class {
   async create(input) {
     return await this.client.pageComment.create.mutate(input);
   }
-  /** Reply to an existing comment. Replies to replies still hang off the root. */
-  async reply(input) {
-    return await this.client.pageComment.reply.mutate(input);
-  }
   async update(input) {
     return await this.client.pageComment.update.mutate(input);
   }
@@ -245,13 +241,6 @@ var PageCommentsApi = class {
       commentId
     });
   }
-  /** Mark an anchored thread resolved. Only anchored threads have a threadId. */
-  async resolve(input) {
-    return await this.client.pageComment.resolve.mutate(input);
-  }
-  async unresolve(input) {
-    return await this.client.pageComment.unresolve.mutate(input);
-  }
 };
 
 // src/goalComments.ts
@@ -530,6 +519,207 @@ var WorkspacesApi = class {
   }
 };
 
+// src/ceremonies.ts
+var CeremoniesApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Built-in templates, one per kind — the "Add from template" list. */
+  async templates() {
+    return await this.client.ceremony.templates.query();
+  }
+  /** Ceremonies of a workspace, active first then by name. Inactive ones only on request. */
+  async list(workspaceId, options = {}) {
+    return await this.client.ceremony.list.query({
+      workspaceId,
+      ...options.includeInactive ? { includeInactive: true } : {}
+    });
+  }
+  /** Active ceremonies linked to a project, each with its next planned occurrence. */
+  async listForProject(projectId) {
+    return await this.client.ceremony.listForProject.query({ projectId });
+  }
+  /**
+   * A project's Meetings timeline: occurrences of the ceremonies reviewing it
+   * (one-offs included), two weeks back to one week ahead by default, newest
+   * first, at most `perCeremony` (default 5) per recurring ceremony.
+   */
+  async listOccurrencesForProject(input) {
+    return await this.client.ceremony.listOccurrencesForProject.query(input);
+  }
+  /**
+   * The ceremony that meets in a video room, with the occurrence on at `at`
+   * (default now). Searches all your workspaces unless `workspaceId` narrows
+   * it; null when nothing (or nothing unambiguous) matches.
+   */
+  async matchMeetingUrl(input) {
+    return await this.client.ceremony.matchMeetingUrl.query(input);
+  }
+  /** One ceremony with participants, projects and its recent + upcoming occurrences. */
+  async get(workspaceId, id) {
+    return await this.client.ceremony.get.query({ workspaceId, id });
+  }
+  /** Occurrences starting inside a window, across ceremonies or for one (max 200). */
+  async listOccurrences(input) {
+    return await this.client.ceremony.listOccurrences.query(input);
+  }
+  /** One occurrence — the meeting page — with its agenda, ceremony and recordings. */
+  async getOccurrence(workspaceId, occurrenceId) {
+    return await this.client.ceremony.getOccurrence.query({
+      workspaceId,
+      occurrenceId
+    });
+  }
+  /** The caller's own async update for an occurrence. */
+  async myUpdate(workspaceId, occurrenceId) {
+    return await this.client.ceremony.myOccurrenceUpdate.query({
+      workspaceId,
+      occurrenceId
+    });
+  }
+  /** Every participant's submitted update, and who hasn't answered. */
+  async updateSummary(workspaceId, occurrenceId) {
+    return await this.client.ceremony.occurrenceUpdateSummary.query({
+      workspaceId,
+      occurrenceId
+    });
+  }
+  /** Draft the caller's answers from their activity since the previous occurrence. */
+  async draftMyUpdate(workspaceId, occurrenceId) {
+    return await this.client.ceremony.draftMyOccurrenceUpdate.mutate({
+      workspaceId,
+      occurrenceId
+    });
+  }
+  /** Save, submit or reopen the caller's own answers. */
+  async saveMyUpdate(input) {
+    return await this.client.ceremony.saveMyOccurrenceUpdate.mutate(input);
+  }
+  /**
+   * Generate or regenerate an occurrence's agenda. `circulate` also notifies
+   * participants and posts to the ceremony's Matrix room, and it re-sends both
+   * if they already went out, so don't retry it blindly.
+   */
+  async generateAgenda(workspaceId, occurrenceId, options = {}) {
+    return await this.client.ceremony.generateAgenda.mutate({
+      workspaceId,
+      occurrenceId,
+      ...options.circulate ? { circulate: true } : {}
+    });
+  }
+  /**
+   * Skip an occurrence with a reason (1-500 characters). Participants are
+   * told. Skipping a booked one-off cancels the meeting: every attendee with an
+   * address gets a calendar cancellation, the ceremony is retired, and it can't
+   * be unskipped.
+   */
+  async skipOccurrence(workspaceId, occurrenceId, reason) {
+    return await this.client.ceremony.skipOccurrence.mutate({
+      workspaceId,
+      occurrenceId,
+      reason
+    });
+  }
+  async unskipOccurrence(workspaceId, occurrenceId) {
+    return await this.client.ceremony.unskipOccurrence.mutate({
+      workspaceId,
+      occurrenceId
+    });
+  }
+  /** Add one occurrence at any time — a meeting off the cadence (owner, or workspace owner/admin). */
+  async addOccurrence(workspaceId, ceremonyId, scheduledStart) {
+    return await this.client.ceremony.addOccurrence.mutate({
+      workspaceId,
+      ceremonyId,
+      scheduledStart
+    });
+  }
+  /**
+   * Move an occurrence that hasn't happened to another time (owner, or
+   * workspace owner/admin). It keeps its agenda, notes, updates and recordings.
+   */
+  async rescheduleOccurrence(workspaceId, occurrenceId, scheduledStart) {
+    return await this.client.ceremony.rescheduleOccurrence.mutate({
+      workspaceId,
+      occurrenceId,
+      scheduledStart
+    });
+  }
+  /** Mark an agenda item resolved, or reopen it. Survives regeneration. */
+  async resolveAgendaItem(workspaceId, occurrenceId, itemId, resolved = true) {
+    return await this.client.ceremony.resolveAgendaItem.mutate({
+      workspaceId,
+      occurrenceId,
+      itemId,
+      resolved
+    });
+  }
+  /** Add an item by hand to an agenda section; kept across regeneration. */
+  async addAgendaItem(input) {
+    return await this.client.ceremony.addAgendaItem.mutate(input);
+  }
+  /** Reorder one section's items; the order is kept across regeneration. */
+  async reorderAgendaItems(workspaceId, occurrenceId, sectionKey, itemIds) {
+    return await this.client.ceremony.reorderAgendaItems.mutate({
+      workspaceId,
+      occurrenceId,
+      sectionKey,
+      itemIds
+    });
+  }
+  /** Post the agenda to the ceremony's Matrix room. A repost needs `confirmRepost`. */
+  async postAgendaToMatrix(workspaceId, occurrenceId, options = {}) {
+    return await this.client.ceremony.postAgendaToMatrix.mutate({
+      workspaceId,
+      occurrenceId,
+      ...options.confirmRepost ? { confirmRepost: true } : {}
+    });
+  }
+  /** Take one of the bot's agenda posts back out of its Matrix room. `eventId` comes from `agenda.matrixPosts`. */
+  async removeAgendaFromMatrix(workspaceId, occurrenceId, eventId) {
+    return await this.client.ceremony.removeAgendaFromMatrix.mutate({
+      workspaceId,
+      occurrenceId,
+      eventId
+    });
+  }
+  /** Create a ceremony and its first occurrences for the rolling window. */
+  async create(input) {
+    return await this.client.ceremony.create.mutate(input);
+  }
+  async update(input) {
+    return await this.client.ceremony.update.mutate(input);
+  }
+  /** Upsert definitions by slug. Keys a definition omits are left untouched. */
+  async importDefinitions(input) {
+    return await this.client.ceremony.importDefinitions.mutate(input);
+  }
+  /**
+   * Attach unattached recordings to occurrences by alias. Defaults to a dry
+   * run — the report is the review step; pass `dryRun: false` to write. Even a
+   * dry run writes one thing: it schedules any missing occurrences of active
+   * ceremonies, so that historical ones exist to attach to.
+   */
+  async backfillAttachments(workspaceId, options = {}) {
+    return await this.client.ceremony.backfillAttachments.mutate({
+      workspaceId,
+      dryRun: options.dryRun ?? true
+    });
+  }
+  /** Link a recorded meeting to the occurrence it captured (same workspace). */
+  async attachMeeting(meetingId, occurrenceId) {
+    return await this.client.ceremony.attachMeeting.mutate({
+      meetingId,
+      occurrenceId
+    });
+  }
+  async detachMeeting(meetingId) {
+    return await this.client.ceremony.detachMeeting.mutate({
+      meetingId
+    });
+  }
+};
+
 // src/contacts.ts
 var ContactsApi = class {
   constructor(client) {
@@ -1646,6 +1836,7 @@ var ExponentialClient = class {
     this.goals = new GoalsApi(this.client, this.keyResults);
     this.projects = new ProjectsApi(this.client);
     this.workspaces = new WorkspacesApi(this.client);
+    this.ceremonies = new CeremoniesApi(this.client);
     this.contacts = new ContactsApi(this.client);
     this.decisions = new DecisionsApi(this.client);
     this.organizations = new OrganizationsApi(this.client);
@@ -1678,6 +1869,8 @@ var ExponentialClient = class {
   keyResults;
   projects;
   workspaces;
+  /** Ceremonies and their occurrences (ADR-0059). */
+  ceremonies;
   contacts;
   decisions;
   organizations;
@@ -1704,6 +1897,7 @@ var ExponentialClient = class {
 };
 export {
   AgentRunsApi,
+  CeremoniesApi,
   DEFAULT_GAP_MINUTES,
   ExponentialClient,
   ROUND_MINUTES,