@planescrm/sdk 0.3.0 → 0.55.0

package/dist/index.mjs

@@ -134,6 +134,28 @@ async function refreshAccessToken(options) {
   }
   return await response.json();
 }
+async function clientCredentialsGrant(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const url = `${baseUrl}/oauth/token`;
+  const body = new URLSearchParams({
+    grant_type: "client_credentials",
+    client_id: options.clientId,
+    client_secret: options.clientSecret,
+    scope: options.scopes.join(" ")
+  });
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({}));
+    const errorCode = errorBody["error"] ?? "unknown_error";
+    const errorDescription = errorBody["error_description"] ?? "Client credentials grant failed";
+    throw new OAuthError(errorCode, errorDescription);
+  }
+  return await response.json();
+}
 
 // src/http.ts
 var HttpClient = class {
@@ -149,7 +171,8 @@ var HttpClient = class {
         clientId: config.clientId,
         clientSecret: config.clientSecret,
         tokenStorage: config.tokenStorage ?? new MemoryTokenStorage(),
-        skewMs: config.tokenRefreshSkewMs ?? DEFAULT_TOKEN_REFRESH_SKEW_MS
+        skewMs: config.tokenRefreshSkewMs ?? DEFAULT_TOKEN_REFRESH_SKEW_MS,
+        scopes: config.scopes
       };
     }
   }
@@ -177,6 +200,9 @@ var HttpClient = class {
         if (response.status === 204) {
           return void 0;
         }
+        if (options.responseType === "arrayBuffer") {
+          return await response.arrayBuffer();
+        }
         return await response.json();
       }
       if (response.status === 429 && this.retryOnRateLimit && attempt < this.maxRetries) {
@@ -242,7 +268,19 @@ var HttpClient = class {
     this.refreshInFlight = (async () => {
       const current = await oauth.tokenStorage.getTokens();
       if (!current?.refreshToken) {
-        throw new AuthenticationError("No refresh token available to refresh the access token");
+        const response2 = await clientCredentialsGrant({
+          baseUrl: this.baseUrl,
+          clientId: oauth.clientId,
+          clientSecret: oauth.clientSecret,
+          scopes: oauth.scopes ?? []
+        });
+        const next2 = {
+          accessToken: response2.access_token,
+          refreshToken: response2.refresh_token ?? null,
+          expiresAt: Date.now() + response2.expires_in * 1e3
+        };
+        await oauth.tokenStorage.setTokens(next2);
+        return next2;
       }
       const response = await refreshAccessToken({
         baseUrl: this.baseUrl,
@@ -320,11 +358,13 @@ var HttpClient = class {
 };
 
 // src/resources/base-resource.ts
-var BaseResource = class {
+var ApiResource = class {
   constructor(http2, basePath) {
     this.http = http2;
     this.basePath = basePath;
   }
+};
+var BaseResource = class extends ApiResource {
   /**
    * List entities with optional filters and pagination.
    */
@@ -375,11 +415,46 @@ var BaseResource = class {
   }
 };
 
+// src/resources/query-params.ts
+function toQueryParams(params) {
+  const out = {};
+  if (!params) return out;
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      out[key] = value.map(String).join(",");
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
 // src/resources/opportunities.ts
 var OpportunityResource = class extends BaseResource {
   constructor(http2) {
     super(http2, "/opportunities");
   }
+  /**
+   * List opportunities. `tag_ids` is ANY-of and travels as one comma-separated
+   * query value (`?tag_ids=a,b`), which is what the API's filter schema parses.
+   */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params: toQueryParams(params)
+    });
+  }
+  /** PUT /opportunities/{id} — partial update; stage moves go through workflow transitions. */
+  async update(id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `${this.basePath}/${id}`,
+      body: data
+    });
+  }
 };
 
 // src/resources/customers.ts
@@ -387,19 +462,125 @@ var CustomerResource = class extends BaseResource {
   constructor(http2) {
     super(http2, "/customers");
   }
+  /**
+   * Update a customer. The API route is `PUT /customers/{id}` (not PATCH like
+   * the other resources), so this overrides the base verb; the body is still a
+   * partial — send only the fields to change. See `UpdateCustomerDto.address`
+   * for how a service address resolves to a property.
+   */
+  async update(id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/customers/${id}`,
+      body: data
+    });
+  }
+  /**
+   * List customers. `tag_ids` is ANY-of and travels as one comma-separated
+   * query value (`?tag_ids=a,b`), which is what the API's filter schema parses.
+   */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params: toQueryParams(params)
+    });
+  }
+  /**
+   * Fold a duplicate company (`loserId`) into a survivor (`winnerId`).
+   *
+   * Everything hanging off the loser moves to the winner, the winner's empty
+   * fields are filled from the loser, and the loser is soft-deleted with a
+   * resolvable pointer — `GET /customers/{loserId}` afterwards returns the
+   * winner's detail with a `mergedFrom` pointer, so a stored loser id keeps
+   * working. Irreversible; requires admin scope.
+   */
+  async merge(winnerId, loserId) {
+    return this.http.request({
+      method: "POST",
+      path: `/customers/${winnerId}/merge/${loserId}`
+    });
+  }
 };
 
 // src/resources/properties.ts
-var PropertyResource = class extends BaseResource {
+var PropertyResource = class extends ApiResource {
   constructor(http2) {
     super(http2, "/properties");
   }
+  /** GET /customers/{customerId}/properties — paginated (`page`, `limit` ≤ 100). */
+  async list(customerId, params) {
+    return this.http.request({
+      method: "GET",
+      path: `/customers/${customerId}/properties`,
+      params: toQueryParams(params)
+    });
+  }
+  /** GET /properties/{id} — one property, without naming its customer. */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}`
+    });
+  }
+  /** POST /customers/{customerId}/properties — the property inherits the customer's org path. */
+  async create(customerId, data) {
+    return this.http.request({
+      method: "POST",
+      path: `/customers/${customerId}/properties`,
+      body: data
+    });
+  }
+  /** PUT /customers/{customerId}/properties/{id} — partial update. */
+  async update(customerId, id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/customers/${customerId}/properties/${id}`,
+      body: data
+    });
+  }
+  /** DELETE /customers/{customerId}/properties/{id} — soft delete (204). */
+  async delete(customerId, id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/customers/${customerId}/properties/${id}`
+    });
+  }
 };
 
 // src/resources/calendar-events.ts
 var CalendarEventResource = class extends BaseResource {
   constructor(http2) {
-    super(http2, "/calendar-events");
+    super(http2, "/events");
+  }
+  async list(params) {
+    return super.list(params);
+  }
+  /**
+   * PATCH /events/:id. For an occurrence of a recurring event, `editMode`
+   * picks which occurrences change (`this` when omitted — the server's
+   * default); it is ignored for one-time events.
+   */
+  async update(id, data, options = {}) {
+    return this.http.request({
+      method: "PATCH",
+      path: `${this.basePath}/${id}`,
+      params: { recurrence_edit_mode: options.editMode },
+      body: data
+    });
+  }
+  /**
+   * POST /events/:id/complete — marks the event completed and runs its "on
+   * complete" transition, best-effort. The event is completed even when the
+   * transition can't run; `workflow_trigger` says whether it fired, was
+   * skipped (none set) or failed (with a reason).
+   */
+  async complete(id, body = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/complete`,
+      body
+    });
   }
 };
 
@@ -411,30 +592,219 @@ var ContractResource = class extends BaseResource {
 };
 
 // src/resources/jobs.ts
-var JobResource = class extends BaseResource {
+var JobResource = class extends ApiResource {
   constructor(http2) {
     super(http2, "/jobs");
   }
+  /** The jobs under one opportunity — the same route as `listForOpportunity()`. */
+  async list(opportunityId, params) {
+    return this.listForOpportunity(opportunityId, params);
+  }
+  /**
+   * List the jobs under one opportunity — `GET /opportunities/{opportunityId}/jobs`,
+   * the API's job list route. Default order is `created_at` desc;
+   * `sort_by: 'recent'` puts the calling user's most recently opened jobs first.
+   */
+  async listForOpportunity(opportunityId, params) {
+    return this.http.request({
+      method: "GET",
+      path: `/opportunities/${opportunityId}/jobs`,
+      params: toQueryParams(params)
+    });
+  }
+  /** GET /opportunities/{opportunityId}/jobs/{id} */
+  async get(opportunityId, id) {
+    return this.http.request({
+      method: "GET",
+      path: `/opportunities/${opportunityId}/jobs/${id}`
+    });
+  }
+  /**
+   * POST /opportunities/{opportunityId}/jobs — 422 WORKFLOW_NOT_CONFIGURED when
+   * the trade has no published job workflow (check `getTradeCoverage()` first).
+   */
+  async create(opportunityId, data) {
+    return this.http.request({
+      method: "POST",
+      path: `/opportunities/${opportunityId}/jobs`,
+      body: data
+    });
+  }
+  /** PUT /opportunities/{opportunityId}/jobs/{id} — partial update (status, notes). */
+  async update(opportunityId, id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/opportunities/${opportunityId}/jobs/${id}`,
+      body: data
+    });
+  }
+  /** DELETE /opportunities/{opportunityId}/jobs/{id} — soft delete (204). */
+  async delete(opportunityId, id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/opportunities/${opportunityId}/jobs/${id}`
+    });
+  }
+  /**
+   * GET /jobs/trade-coverage — every active trade with whether a job can be
+   * created under it (a published job workflow resolves: the trade's own or the
+   * generic one). Check before creating a job to avoid a 422
+   * WORKFLOW_NOT_CONFIGURED. Readable by any role that can create jobs (403
+   * otherwise); carries no workflow details.
+   */
+  async getTradeCoverage() {
+    return this.http.request({
+      method: "GET",
+      path: "/jobs/trade-coverage"
+    });
+  }
 };
 
 // src/resources/estimates.ts
-var EstimateResource = class extends BaseResource {
+var EstimateResource = class extends ApiResource {
   constructor(http2) {
     super(http2, "/estimates");
   }
+  /** GET /jobs/{jobId}/estimates — newest first, paginated (`page`, `limit` ≤ 100). */
+  async list(jobId, params) {
+    return this.http.request({
+      method: "GET",
+      path: `/jobs/${jobId}/estimates`,
+      params: toQueryParams(params)
+    });
+  }
+  /**
+   * Every estimate across all of one opportunity's jobs, in one request —
+   * `GET /opportunities/{opportunityId}/estimates`. Newest first; each row
+   * carries its `jobId`. Paginated with `page` / `limit` (max 100).
+   */
+  async listForOpportunity(opportunityId, params) {
+    return this.http.request({
+      method: "GET",
+      path: `/opportunities/${opportunityId}/estimates`,
+      params: toQueryParams(params)
+    });
+  }
+  /** GET /jobs/{jobId}/estimates/{id} — the estimate with its line items. */
+  async get(jobId, id) {
+    return this.http.request({
+      method: "GET",
+      path: `/jobs/${jobId}/estimates/${id}`
+    });
+  }
+  /** POST /jobs/{jobId}/estimates — optionally cloned from an estimate template. */
+  async create(jobId, data) {
+    return this.http.request({
+      method: "POST",
+      path: `/jobs/${jobId}/estimates`,
+      body: data
+    });
+  }
+  /** PUT /jobs/{jobId}/estimates/{id} — partial update (measurements, notes, discount, tax). */
+  async update(jobId, id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/jobs/${jobId}/estimates/${id}`,
+      body: data
+    });
+  }
+  /** DELETE /jobs/{jobId}/estimates/{id} — soft delete (204). */
+  async delete(jobId, id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/jobs/${jobId}/estimates/${id}`
+    });
+  }
 };
 
 // src/resources/invoices.ts
 var InvoiceResource = class extends BaseResource {
   constructor(http2) {
-    super(http2, "/invoices");
+    super(http2, "/admin/invoices");
+  }
+  /** List invoices, newest first. Each row carries the customer's `customerName`. */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params
+    });
+  }
+  /**
+   * GET /admin/invoices/:id — the invoice with its line items, payments
+   * (including any `needs_review` payment) and `payLink` state.
+   */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}`
+    });
+  }
+  /**
+   * POST /admin/invoices/:id/pay-link — issue a fresh durable pay link for a
+   * `sent` or `partially_paid` invoice (Send Invoice grant) and return its URL,
+   * e.g. to share by text. Rotates: the previously emailed link stops working.
+   * Any other status → 409 `INVOICE_NOT_PAYABLE`.
+   */
+  async createPayLink(id) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/pay-link`
+    });
+  }
+  /**
+   * GET /admin/invoices/:id/pdf — the invoice PDF bytes (Read Invoice grant).
+   * A sent invoice returns the copy stored when it was sent; a draft renders on
+   * demand with a DRAFT watermark.
+   */
+  async downloadPdf(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}/pdf`,
+      headers: { Accept: "application/pdf" },
+      responseType: "arrayBuffer"
+    });
+  }
+  /**
+   * GET /admin/invoices/overdue — sent / partially paid invoices with a balance
+   * past their due date, most overdue first, each with `daysOverdue` and the
+   * last overdue offset reached (E56-F8-S2). Read Invoice.
+   */
+  async listOverdue(params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/overdue`,
+      params
+    });
+  }
+  /** GET /admin/invoices/overdue/summary — `{ count, total }` of every overdue invoice. Read Invoice. */
+  async overdueSummary() {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/overdue/summary`
+    });
   }
 };
 
 // src/resources/inventory.ts
 var InventoryResource = class extends BaseResource {
   constructor(http2) {
-    super(http2, "/inventory/items");
+    super(http2, "/admin/inventory/items");
+  }
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params: toQueryParams(params)
+    });
+  }
+  /** PUT /admin/inventory/items/{id} — partial update. */
+  async update(id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `${this.basePath}/${id}`,
+      body: data
+    });
   }
 };
 
@@ -470,6 +840,20 @@ var ContactResource = class extends BaseResource {
   constructor(http2) {
     super(http2, "/contacts");
   }
+  /**
+   * List contacts. Typed against the real filter schema (customer_id /
+   * property_id / q / sort_by / sort_order / page / limit / include) — the base
+   * `list` would accept any key and let a typo reach the server as a 400.
+   * `include: ['channels', 'links']` attaches each row's channels and active
+   * links in the same response.
+   */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params: toQueryParams(params)
+    });
+  }
   async merge(winnerId, loserId) {
     return this.http.request({
       method: "POST",
@@ -509,43 +893,1030 @@ var ActivityResource = class {
   }
 };
 
-// src/resources/tags.ts
-var TagResource = class extends BaseResource {
+// src/resources/communications.ts
+var CommunicationsResource = class {
   constructor(http2) {
-    super(http2, "/tags");
+    this.http = http2;
   }
-  /** `TagsService.setEntityTags()` returns the final tag set wrapped in `{ tags }`. */
-  async setEntityTags(entityType, entityId, data) {
+  async log(data) {
     return this.http.request({
-      method: "PUT",
-      path: `/entities/${entityType}/${entityId}/tags`,
+      method: "POST",
+      path: "/communications",
       body: data
     });
   }
-  async getEntityTags(entityType, entityId) {
+  async list(params) {
     return this.http.request({
       method: "GET",
-      path: `/entities/${entityType}/${entityId}/tags`
+      path: "/communications",
+      params
     });
   }
-  async getEntities(tagId, params) {
+  async get(id) {
     return this.http.request({
       method: "GET",
-      path: `/tags/${tagId}/entities`,
-      params
+      path: `/communications/${id}`
+    });
+  }
+  async link(id, data) {
+    return this.http.request({
+      method: "POST",
+      path: `/communications/${id}/link`,
+      body: data
     });
   }
 };
 
-// src/webhooks.ts
-import { createHmac, timingSafeEqual } from "crypto";
-function verifyWebhookSignature(payload, signature, secret) {
-  if (!signature || !secret || !payload) {
-    return false;
+// src/resources/conversations.ts
+var ConversationsResource = class {
+  constructor(http2) {
+    this.http = http2;
   }
-  const prefix = "sha256=";
-  if (!signature.startsWith(prefix)) {
-    return false;
+  async log(data) {
+    return this.http.request({ method: "POST", path: "/conversations", body: data });
+  }
+  async list(params) {
+    return this.http.request({ method: "GET", path: "/conversations", params });
+  }
+  /** The review queue: `list()` pinned to `match_status: 'needs_review'`. */
+  async reviewQueue(params) {
+    return this.list({ ...params, match_status: "needs_review" });
+  }
+  async get(id) {
+    return this.http.request({ method: "GET", path: `/conversations/${encodeURIComponent(id)}` });
+  }
+  async update(id, data) {
+    return this.http.request({ method: "PATCH", path: `/conversations/${encodeURIComponent(id)}`, body: data });
+  }
+  async delete(id) {
+    await this.http.request({ method: "DELETE", path: `/conversations/${encodeURIComponent(id)}` });
+  }
+  async link(id, data) {
+    return this.http.request({ method: "POST", path: `/conversations/${encodeURIComponent(id)}/links`, body: data });
+  }
+  async unlink(id, linkId) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/conversations/${encodeURIComponent(id)}/links/${encodeURIComponent(linkId)}`
+    });
+  }
+  async resolve(id, data) {
+    return this.http.request({ method: "POST", path: `/conversations/${encodeURIComponent(id)}/resolve`, body: data });
+  }
+  async getInternalDomains() {
+    return this.http.request({ method: "GET", path: "/conversations/settings/internal-domains" });
+  }
+  /** Requires an admin: the server checks `Update` on `Subject.Tenant` (tenant-wide matching config), not `Subject.Conversation`. */
+  async setInternalDomains(data) {
+    return this.http.request({ method: "PUT", path: "/conversations/settings/internal-domains", body: data });
+  }
+  /**
+   * E57-F2-S4 — disconnect the CALLER's own Circleback connection (Update
+   * Conversation). Another user's connection id is a 404. Connecting is the
+   * interactive browser OAuth flow (Settings → Conversations), not an SDK call.
+   */
+  async disconnectCircleback(data) {
+    return this.http.request({
+      method: "POST",
+      path: "/conversations/sources/circleback/disconnect",
+      body: data
+    });
+  }
+  /**
+   * E57-F2-S8 — pull one company's meetings from every active teammate's
+   * connected source (Update Conversation). 202, runs in the background.
+   * 404 for a company you can't see; 409 `NO_SOURCES` when nobody has one.
+   */
+  async pull(data) {
+    return this.http.request({ method: "POST", path: "/conversations/pull", body: data });
+  }
+  /**
+   * E57-F2-S9 — whether a Pull has finished: pass the `job_ids` `pull()`
+   * returned (1–50). Update Conversation, like `pull()`. 404
+   * `PULL_NOT_FOUND` when none of them is readable (expired after ~2h,
+   * unknown) — treat that as settled.
+   */
+  async getPullStatus(jobIds) {
+    return this.http.request({
+      method: "GET",
+      path: "/conversations/pull/status",
+      params: { job_ids: jobIds.join(",") }
+    });
+  }
+  /** E57-F2-S8 — sync the caller's OWN Circleback connection now (deduplicated). 409 `NO_CONNECTION` when they have none. */
+  async syncNow() {
+    return this.http.request({ method: "POST", path: "/conversations/sources/circleback/sync-now" });
+  }
+  /** E57-F2-S8 — the caller's own connection, `has_sources`, and (admins only) the roster. */
+  async syncStatus() {
+    return this.http.request({ method: "GET", path: "/conversations/sync-status" });
+  }
+  /**
+   * E57-F4-S1 — a synced meeting's transcript, fetched live from the meeting
+   * recorder (never stored by Planes; the response is `Cache-Control:
+   * no-store`). Read Conversation, plus the tenant's transcript-access rule:
+   * 403 `TRANSCRIPT_OWNER_ONLY` under `owner` for a non-owner; 409
+   * `TRANSCRIPT_SOURCE_UNAVAILABLE` (`owner_name` says who must reconnect) or
+   * `TRANSCRIPT_NOT_AVAILABLE` (not a synced meeting); 404 when you can't see
+   * the conversation. `segments: []` = no transcript yet.
+   */
+  async getTranscript(id) {
+    return this.http.request({
+      method: "GET",
+      path: `/conversations/${encodeURIComponent(id)}/transcript`
+    });
+  }
+  /** E57-F4-S1 — who can view transcripts: `owner` (default) or `viewers`. Read Conversation. */
+  async getTranscriptAccess() {
+    return this.http.request({ method: "GET", path: "/conversations/settings/transcript-access" });
+  }
+  /** E57-F4-S1 — requires an admin: the server checks `Update` on `Subject.Tenant`. */
+  async setTranscriptAccess(value) {
+    return this.http.request({
+      method: "PUT",
+      path: "/conversations/settings/transcript-access",
+      body: { transcript_access: value }
+    });
+  }
+};
+
+// src/resources/gmail.ts
+var GmailResource = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  /**
+   * Send an email RIGHT NOW from the connected user's real Gmail address.
+   * Hits `POST /admin/integrations/google/gmail/send` — final per Task 4
+   * (`apps/api/src/modules/integrations/google/google-connection.controller.ts`).
+   */
+  async send(data) {
+    return this.http.request({
+      method: "POST",
+      path: "/admin/integrations/google/gmail/send",
+      body: data
+    });
+  }
+};
+
+// src/resources/documents.ts
+var DocumentsResource = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  /** Attach an external (link-only) document — e.g. a Google Drive link — to a record. */
+  async attachExternal(data) {
+    return this.http.request({
+      method: "POST",
+      path: "/documents/external",
+      body: data
+    });
+  }
+  /** Documents filed directly on one record (uploaded + external), newest first. */
+  async listForEntity(entityType, entityId) {
+    return this.http.request({
+      method: "GET",
+      path: `/${entityType}/${entityId}/documents`
+    });
+  }
+};
+
+// src/resources/tags.ts
+var TagResource = class extends ApiResource {
+  constructor(http2) {
+    super(http2, "/tags");
+  }
+  /** GET /tags */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params
+    });
+  }
+  /** POST /tags — 409 on a case-insensitive duplicate name. */
+  async create(data) {
+    return this.http.request({ method: "POST", path: this.basePath, body: data });
+  }
+  /** PATCH /tags/:id — rename / recolor; 409 on a case-insensitive duplicate name. */
+  async update(id, data) {
+    return this.http.request({ method: "PATCH", path: `${this.basePath}/${id}`, body: data });
+  }
+  /** DELETE /tags/:id — cascades the tag off every record. */
+  async delete(id) {
+    await this.http.request({ method: "DELETE", path: `${this.basePath}/${id}` });
+  }
+  /** `TagsService.setEntityTags()` returns the final tag set wrapped in `{ tags }`. */
+  async setEntityTags(entityType, entityId, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/entities/${entityType}/${entityId}/tags`,
+      body: data
+    });
+  }
+  async getEntityTags(entityType, entityId) {
+    return this.http.request({
+      method: "GET",
+      path: `/entities/${entityType}/${entityId}/tags`
+    });
+  }
+  async getEntities(tagId, params) {
+    return this.http.request({
+      method: "GET",
+      path: `/tags/${tagId}/entities`,
+      params
+    });
+  }
+};
+
+// src/resources/tasks.ts
+var TaskResource = class extends ApiResource {
+  constructor(http2) {
+    super(http2, "/tasks");
+  }
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params
+    });
+  }
+  /** GET /tasks/:id */
+  async get(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}` });
+  }
+  /** POST /tasks */
+  async create(data) {
+    return this.http.request({ method: "POST", path: this.basePath, body: data });
+  }
+  /** PATCH /tasks/:id — non-terminal fields only; terminal status changes use the action methods. */
+  async update(id, data) {
+    return this.http.request({ method: "PATCH", path: `${this.basePath}/${id}`, body: data });
+  }
+  /**
+   * POST /tasks/:id/complete — fires the linked workflow transition (best-effort).
+   * The task always completes; `workflow_trigger` says whether the next step ran.
+   */
+  async complete(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/complete` });
+  }
+  /** POST /tasks/:id/cancel */
+  async cancel(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/cancel` });
+  }
+  /** POST /tasks/:id/reopen — the sanctioned resurrect of a completed/cancelled task. */
+  async reopen(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/reopen` });
+  }
+};
+
+// src/resources/record-views.ts
+var RecordViewsResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/record-views";
+  }
+  /** POST /record-views — record that the calling user opened this record. Resolves on 204. */
+  async touch(input) {
+    await this.http.request({ method: "POST", path: this.basePath, body: input });
+  }
+  /** GET /record-views/recent — the calling user's most recently viewed records, newest first. */
+  async recent(params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/recent`,
+      params: toQueryParams(params)
+    });
+  }
+};
+
+// src/resources/modules.ts
+var ModulesResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/modules";
+  }
+  /** GET /modules — one entry per registered module key, in canonical order. */
+  async list() {
+    const res = await this.http.request({
+      method: "GET",
+      path: this.basePath
+    });
+    return res.data;
+  }
+};
+
+// src/resources/plan.ts
+var PlanResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/plan";
+  }
+  /** GET /plan — plan, billing status and the plan's ceiling. */
+  async get() {
+    const res = await this.http.request({
+      method: "GET",
+      path: this.basePath
+    });
+    return res.data;
+  }
+};
+
+// src/resources/me.ts
+var MeResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/me";
+  }
+  /**
+   * GET /me/abilities — the caller's effective ability: for an API key, the key
+   * role intersected with its acting agent's live role (`actingRole`).
+   */
+  async abilities() {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/abilities`
+    });
+  }
+};
+
+// src/resources/roles.ts
+var RolesResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/roles";
+  }
+  /** GET /roles — every role (not `system_agent`) with user and change counts. */
+  async list() {
+    return this.http.request({ method: "GET", path: this.basePath });
+  }
+  /** GET /roles/:key — one role's permission matrix, summary and grant version. */
+  async get(key) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${encodeURIComponent(key)}`
+    });
+  }
+  /**
+   * PUT /roles/:key/grants — sparse per-cell changes, all validated before any
+   * is written. 422 `GRANT_REQUIRED` / `GRANT_NOT_DELEGABLE` for locked cells,
+   * `CONFIRMATION_REQUIRED` when a money action is granted without
+   * `confirm: true` + `reason`, `ROLE_NOT_TUNABLE` for admin; 409
+   * `ROLE_VERSION_CONFLICT` on a stale `baseVersion`. Returns the updated role.
+   */
+  async updateGrants(key, body) {
+    return this.http.request({
+      method: "PUT",
+      path: `${this.basePath}/${encodeURIComponent(key)}/grants`,
+      body
+    });
+  }
+  /** DELETE /roles/:key/grants — back to the Planes defaults. Returns the reset role. */
+  async reset(key) {
+    return this.http.request({
+      method: "DELETE",
+      path: `${this.basePath}/${encodeURIComponent(key)}/grants`
+    });
+  }
+  /** GET /roles/history — the change log, newest first; page with `cursor`. */
+  async history(params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/history`,
+      ...params ? { params } : {}
+    });
+  }
+};
+
+// src/resources/invoice-settings.ts
+var InvoiceSettingsResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/admin/invoice-settings";
+  }
+  /**
+   * GET /admin/invoice-settings/offline-instructions — the plain-text
+   * instructions shown on the pay page when online payment is unavailable,
+   * or null when none are set.
+   */
+  async getOfflineInstructions() {
+    const res = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/offline-instructions`
+    });
+    return res.instructions;
+  }
+  /**
+   * PUT /admin/invoice-settings/offline-instructions — store plain text
+   * (trimmed, at most 2,000 characters); null or blank clears it. Returns the
+   * stored value.
+   */
+  async setOfflineInstructions(text) {
+    const body = { instructions: text };
+    const res = await this.http.request({
+      method: "PUT",
+      path: `${this.basePath}/offline-instructions`,
+      body
+    });
+    return res.instructions;
+  }
+  /**
+   * GET /admin/invoice-settings/overdue-offsets — the days after the due date
+   * at which `invoice.overdue` fires, ascending (default `[3, 7, 14]`).
+   */
+  async getOverdueOffsets() {
+    const res = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/overdue-offsets`
+    });
+    return res.offsets;
+  }
+  /**
+   * PUT /admin/invoice-settings/overdue-offsets — replace the offsets: 1 to 5
+   * unique whole days, each 1–90. Returns them sorted ascending. Admin only.
+   */
+  async setOverdueOffsets(offsets) {
+    const body = { offsets };
+    const res = await this.http.request({
+      method: "PUT",
+      path: `${this.basePath}/overdue-offsets`,
+      body
+    });
+    return res.offsets;
+  }
+  /**
+   * GET /admin/invoice-settings/attach-pdf — whether invoice emails carry the
+   * invoice PDF (on unless an admin turned it off).
+   */
+  async getAttachPdf() {
+    const res = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/attach-pdf`
+    });
+    return res.enabled;
+  }
+  /**
+   * PUT /admin/invoice-settings/attach-pdf — turn the PDF attachment on
+   * invoice emails on or off. Returns the stored value.
+   */
+  async setAttachPdf(enabled) {
+    const body = { enabled };
+    const res = await this.http.request({
+      method: "PUT",
+      path: `${this.basePath}/attach-pdf`,
+      body
+    });
+    return res.enabled;
+  }
+};
+
+// src/resources/invoice-reminders.ts
+var InvoiceRemindersResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/admin/invoice-reminders";
+  }
+  /** GET /admin/invoice-reminders — the rules, ascending by offset, and the overdue offsets. */
+  async list() {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath
+    });
+  }
+  /**
+   * PUT /admin/invoice-reminders — replace the WHOLE rule set (a rule left out
+   * is deleted): up to 5 rules at unique offsets. Templates may use only
+   * `{{customerName}}`, `{{invoiceNumber}}`, `{{amountDue}}`, `{{total}}`,
+   * `{{dueDate}}`, `{{daysOverdue}}` and `{{companyName}}`; any other is a 422
+   * `REMINDER_TEMPLATE_INVALID` listing each one. Returns the stored set.
+   */
+  async update(rules) {
+    return this.http.request({
+      method: "PUT",
+      path: this.basePath,
+      body: { rules }
+    });
+  }
+  /**
+   * POST /admin/invoice-reminders/preview — render a subject and body exactly
+   * as the reminder email would, against an invoice or a sample. Sends nothing.
+   */
+  async preview(params) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/preview`,
+      body: params
+    });
+  }
+};
+
+// src/resources/contact-sequences.ts
+var ContactSequencesResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/contact-sequences";
+  }
+  /** GET /contact-sequences — `{ data, meta: { total } }`, name-sorted, max 100. */
+  async list() {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath
+    });
+  }
+};
+
+// src/resources/enrollments.ts
+var EnrollmentsResource = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  /**
+   * POST /contacts/:id/enrollments — `{ workflow_id }`. 409 if the contact is
+   * already active in the sequence; 422 if the sequence has no published version.
+   */
+  async enroll(contactId, workflowId) {
+    return this.http.request({
+      method: "POST",
+      path: `/contacts/${contactId}/enrollments`,
+      body: { workflow_id: workflowId }
+    });
+  }
+  /** GET /contacts/:id/enrollments — a bare array, newest first; optional `status` filter. */
+  async list(contactId, params) {
+    return this.http.request({
+      method: "GET",
+      path: `/contacts/${contactId}/enrollments`,
+      ...params ? { params } : {}
+    });
+  }
+  /**
+   * POST /enrollments/:id/exit — no body; the exit reason is recorded as
+   * `'manual'`. Idempotent: an already-ended enrollment is returned unchanged.
+   */
+  async exit(enrollmentId) {
+    return this.http.request({
+      method: "POST",
+      path: `/enrollments/${enrollmentId}/exit`
+    });
+  }
+};
+
+// src/resources/workflow-event-rules.ts
+var WorkflowEventRulesResource = class {
+  constructor(http2, workflowId) {
+    this.http = http2;
+    this.workflowId = workflowId;
+  }
+  // Each request spells its path out in full (no computed base path) so the
+  // API's SDK route-parity audit (sdk-route-parity-audit.spec.ts) can read it.
+  /** GET — a bare array of the workflow's live rules, newest first. 404 `WORKFLOW_NOT_FOUND`. */
+  async list() {
+    return this.http.request({
+      method: "GET",
+      path: `/admin/workflows/${encodeURIComponent(this.workflowId)}/event-rules`
+    });
+  }
+  /**
+   * POST — add a rule (201). `when` defaults to `{}` and `enabled` to true; use
+   * `when: {}` for the creation types in `WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES`.
+   * 400 `VALIDATION_FAILED` for a bad body; 404 `WORKFLOW_NOT_FOUND`.
+   */
+  async create(input) {
+    return this.http.request({
+      method: "POST",
+      path: `/admin/workflows/${encodeURIComponent(this.workflowId)}/event-rules`,
+      body: input
+    });
+  }
+  /** PATCH /:id — only the fields sent change (at least one). 404 `EVENT_RULE_NOT_FOUND`. */
+  async update(ruleId, input) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/admin/workflows/${encodeURIComponent(this.workflowId)}/event-rules/${encodeURIComponent(ruleId)}`,
+      body: input
+    });
+  }
+  /** DELETE /:id — soft delete; returns `{ id }` (200). 404 `EVENT_RULE_NOT_FOUND`. */
+  async delete(ruleId) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/admin/workflows/${encodeURIComponent(this.workflowId)}/event-rules/${encodeURIComponent(ruleId)}`
+    });
+  }
+};
+
+// src/resources/workflows.ts
+var WorkflowsResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/workflows";
+    this.adminPath = "/admin/workflows";
+  }
+  /**
+   * GET /workflows/:id/stages — the ordered stages of one workflow version. Pass
+   * a record's instance `workflowId` (e.g. from `GET /opportunities/:id/workflow`)
+   * to get the stages of the version that record is pinned to, even an archived
+   * one. 404 for an unknown or draft id; 403 if the caller cannot read the
+   * workflow's record type.
+   */
+  async getStages(workflowId) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${encodeURIComponent(workflowId)}/stages`
+    });
+  }
+  /**
+   * GET /workflows/transitions — transition summaries of every published
+   * workflow, or with `workflowId` of that one version (published or archived;
+   * an unknown, draft or other-tenant id returns an empty list). Each summary
+   * carries `workflow_id`, `workflow_version`, `lineage_workflow_id` and
+   * `automatic_only`. Only pipelines whose record type the caller can read
+   * are listed; an unreadable `workflowId` returns an empty list, not 403.
+   */
+  async listTransitions(params = {}) {
+    const query = {};
+    if (params.entityTypes && params.entityTypes.length > 0) query["entity_types"] = params.entityTypes.join(",");
+    if (params.workflowId) query["workflow_id"] = params.workflowId;
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/transitions`,
+      params: query
+    });
+  }
+  /**
+   * POST /admin/workflows/:wid/transitions — add a transition to a draft
+   * workflow. Pass `automaticOnly: true` for an edge only automation should
+   * fire (e.g. an event rule advancing on "contract sent").
+   */
+  async createTransition(workflowId, input) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.adminPath}/${encodeURIComponent(workflowId)}/transitions`,
+      body: input
+    });
+  }
+  /**
+   * The event rules of one workflow (`/admin/workflows/:wid/event-rules`) —
+   * "advance automatically when…". Any version's id works; rules are keyed by
+   * the lineage root.
+   */
+  eventRules(workflowId) {
+    return new WorkflowEventRulesResource(this.http, workflowId);
+  }
+  /** PUT /admin/workflows/:wid/transitions/:tid — update a draft workflow's transition. */
+  async updateTransition(workflowId, transitionId, input) {
+    return this.http.request({
+      method: "PUT",
+      path: `${this.adminPath}/${encodeURIComponent(workflowId)}/transitions/${encodeURIComponent(transitionId)}`,
+      body: input
+    });
+  }
+};
+
+// src/resources/service-schedules.ts
+var ServiceSchedulesResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/service-schedules";
+  }
+  /**
+   * POST /service-schedules/conflicts/preview — before booking people, see
+   * who is already on another event (`conflicts`) and who would be outside
+   * their working hours (`working_hours`). Read-only and warn-only: nothing
+   * is ever blocked. Give exactly one of `windows` (single booking) or
+   * `schedule` (a cadence). 400 on invalid input, INVALID_RECURRENCE_RULE,
+   * INVALID_TIMEZONE or TOO_MANY_WINDOWS (> 400).
+   */
+  async previewConflicts(request) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/conflicts/preview`,
+      body: request
+    });
+  }
+};
+
+// src/resources/billing-schedules.ts
+var BillingScheduleResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/admin/billing-schedules");
+  }
+  /** GET /admin/billing-schedules — list rows (no lines; `line_count` and `next_amount` instead). */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params: toQueryParams(params)
+    });
+  }
+  /** GET /admin/billing-schedules/:id — the schedule with its lines and next 3 periods. */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${encodeURIComponent(id)}`
+    });
+  }
+  /**
+   * POST /admin/billing-schedules. `timezone` defaults to the tenant's. A
+   * backdated `start_date` needs `backfill` ('skip' | 'draft'), else 400
+   * `BACKFILL_REQUIRED`; `collection: 'autopay'` without a platform-managed
+   * Stripe connection and a saved default card is 422 `AUTOPAY_UNAVAILABLE`
+   * (`reason` `no_connect` | `no_saved_method`).
+   */
+  async create(data) {
+    return this.http.request({
+      method: "POST",
+      path: this.basePath,
+      body: data
+    });
+  }
+  /**
+   * PATCH /admin/billing-schedules/:id — partial. `lines` replaces every line
+   * from `effective_from` (default: the next period not yet invoiced) as a new
+   * line version. 409 `CADENCE_LOCKED`; 422 `EFFECTIVE_DATE_IN_GENERATED_PERIOD`
+   * for a date inside an invoiced period.
+   */
+  async update(id, data) {
+    return this.http.request({
+      method: "PATCH",
+      path: `${this.basePath}/${encodeURIComponent(id)}`,
+      body: data
+    });
+  }
+  /** DELETE /admin/billing-schedules/:id — only a schedule that never invoiced (else 409 `SCHEDULE_HAS_INVOICES`). */
+  async delete(id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `${this.basePath}/${encodeURIComponent(id)}`
+    });
+  }
+  /** GET /admin/billing-schedules/:id/versions — line version history, newest effective date first. */
+  async listVersions(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${encodeURIComponent(id)}/versions`
+    });
+  }
+  /**
+   * POST /admin/billing-schedules/:id/adjustments — add a one-off amount
+   * (signed; negative is a credit) to the schedule's next generated invoice.
+   * Billed exactly once; no automatic proration. 422 `ADJUSTMENT_INVALID`
+   * (zero, or the next invoice would go below zero) or `SCHEDULE_NOT_ACTIVE`.
+   */
+  async addAdjustment(id, data) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${encodeURIComponent(id)}/adjustments`,
+      body: data
+    });
+  }
+  /** GET /admin/billing-schedules/:id/adjustments — oldest first; default pending and consumed. */
+  async listAdjustments(id, params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${encodeURIComponent(id)}/adjustments`,
+      params: toQueryParams(params)
+    });
+  }
+  /**
+   * DELETE /admin/billing-schedules/:id/adjustments/:adjustmentId — cancel a
+   * pending adjustment (it never bills). Returns it; 409
+   * `ADJUSTMENT_ALREADY_CONSUMED` once an invoice carries it.
+   */
+  async cancelAdjustment(id, adjustmentId) {
+    return this.http.request({
+      method: "DELETE",
+      path: `${this.basePath}/${encodeURIComponent(id)}/adjustments/${encodeURIComponent(adjustmentId)}`
+    });
+  }
+  /** POST /admin/billing-schedules/:id/pause — 409 `INVALID_STATUS_TRANSITION` unless active. */
+  async pause(id) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${encodeURIComponent(id)}/pause`
+    });
+  }
+  /** POST /admin/billing-schedules/:id/resume — periods that fell due while paused are skipped. */
+  async resume(id) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${encodeURIComponent(id)}/resume`
+    });
+  }
+  /** POST /admin/billing-schedules/:id/end — no further periods generate. */
+  async end(id) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${encodeURIComponent(id)}/end`
+    });
+  }
+  /** GET /admin/billing-schedules/:id/preview — the next `count` (1–24, default 6) periods from the first unbilled one. */
+  async preview(id, params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${encodeURIComponent(id)}/preview`,
+      params: toQueryParams(params)
+    });
+  }
+  /** GET /admin/billing-schedules/:id/periods — the period ledger, newest first. */
+  async periods(id, params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${encodeURIComponent(id)}/periods`,
+      params: toQueryParams(params)
+    });
+  }
+  /**
+   * GET /admin/billing-schedules/periods/needs-review — tenant-wide: needs_review
+   * rows plus failed and stuck (pending over 2h) deliveries.
+   */
+  async needsReview(params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/periods/needs-review`,
+      params: toQueryParams(params)
+    });
+  }
+  /**
+   * GET /admin/billing-schedules/autopay-summary — what disconnecting Stripe
+   * would touch: live autopay schedules, the distinct customers on them, and
+   * active saved cards on the current Stripe connection. On disconnect, autopay
+   * schedules that can no longer charge switch to emailed pay links.
+   */
+  async autopaySummary() {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/autopay-summary`
+    });
+  }
+  /**
+   * POST /admin/billing-schedules/:id/generate-now — bill the current due
+   * period now. Idempotent (`already_generated`); 409 `NOTHING_DUE` or
+   * `SCHEDULE_NOT_ACTIVE`.
+   */
+  async generateNow(id) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${encodeURIComponent(id)}/generate-now`
+    });
+  }
+  /**
+   * POST /admin/billing-schedules/:id/periods/:periodStart/skip — skip one
+   * period (`periodStart` is `YYYY-MM-DD`). Returns the skipped ledger row;
+   * 400 `NOT_A_PERIOD`, 409 `PERIOD_ALREADY_INVOICED`.
+   */
+  async skipPeriod(id, periodStart, data = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${encodeURIComponent(id)}/periods/${encodeURIComponent(periodStart)}/skip`,
+      body: data
+    });
+  }
+  /**
+   * POST /admin/billing-schedules/:id/periods/:periodStart/regenerate — re-bill
+   * a period whose invoice was voided (new draft on the same ledger row).
+   * 409 `INVOICE_NOT_VOID` or `CHECKOUT_IN_FLIGHT`.
+   */
+  async regeneratePeriod(id, periodStart) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${encodeURIComponent(id)}/periods/${encodeURIComponent(periodStart)}/regenerate`
+    });
+  }
+};
+
+// src/resources/custom-fields.ts
+var CustomFieldsResource = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  /** List definitions, optionally narrowed to one entity type. */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: "/custom-fields",
+      params
+    });
+  }
+};
+
+// src/resources/ortto.ts
+var OrttoResource = class {
+  constructor(http2) {
+    this.http = http2;
+    this.basePath = "/admin/integrations/ortto";
+  }
+  /** GET /admin/integrations/ortto/mappings — live mappings with their list names. */
+  async listMappings() {
+    const res = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/mappings`
+    });
+    return res.data;
+  }
+  /** GET /admin/integrations/ortto/audiences — the connected account's audiences (cached 60 s). */
+  async listAudiences(params) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/audiences`,
+      params
+    });
+    return res.data;
+  }
+  /** POST /admin/integrations/ortto/mappings — 409 when the list already has a mapping. */
+  async createMapping(data) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `${this.basePath}/mappings`,
+      body: data
+    });
+    return res.data;
+  }
+  /** PATCH /admin/integrations/ortto/mappings/:id — `ortto_tag` and/or `create_unmatched`. */
+  async updateMapping(id, data) {
+    const res = await this.http.request({
+      method: "PATCH",
+      path: `${this.basePath}/mappings/${id}`,
+      body: data
+    });
+    return res.data;
+  }
+  /**
+   * DELETE /admin/integrations/ortto/mappings/:id (204). A pull list becomes
+   * editable again and keeps its members; a push tag is NOT removed from Ortto.
+   */
+  async deleteMapping(id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `${this.basePath}/mappings/${id}`
+    });
+  }
+  /**
+   * POST /admin/integrations/ortto/sync (202) — queue a sync for one mapping or
+   * the whole connection. Never calls Ortto in-request.
+   */
+  async sync(data = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `${this.basePath}/sync`,
+      body: data
+    });
+    return res.data;
+  }
+  /** GET /admin/integrations/ortto/sync-status — 404 when Ortto is not connected. */
+  async syncStatus() {
+    const res = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/sync-status`
+    });
+    return res.data;
+  }
+};
+
+// src/webhooks.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var WEBHOOK_EVENT_TYPES = [
+  "created",
+  "updated",
+  "deleted",
+  "status_changed",
+  "entity.tagged",
+  "entity.untagged",
+  "list.member_added",
+  "list.member_removed",
+  "entity.assigned",
+  "entity.unassigned",
+  "team.member_added",
+  "team.member_removed",
+  "task.created",
+  "task.updated",
+  "task.completed",
+  "task.cancelled",
+  "comment.created",
+  "conversation.created",
+  "conversation.matched",
+  "conversation.deleted",
+  "customer.merged",
+  "workflow.instance_moved",
+  "consent.changed",
+  "billing_schedule.period_generated",
+  "billing_schedule.period_needs_review",
+  "billing_schedule.period_delivered",
+  "billing_schedule.period_delivery_failed",
+  "payment.on_void_invoice",
+  "invoice.overdue",
+  "integration_connection.deactivated",
+  "customer_payment_method.invalidated",
+  "invoice.autopay_succeeded",
+  "invoice.autopay_failed"
+];
+function verifyWebhookSignature(payload, signature, secret) {
+  if (!signature || !secret || !payload) {
+    return false;
+  }
+  const prefix = "sha256=";
+  if (!signature.startsWith(prefix)) {
+    return false;
   }
   const receivedHex = signature.slice(prefix.length);
   if (!receivedHex) {
@@ -708,12 +2079,142 @@ var PlanesClient = class {
     }
     return this._activities;
   }
+  get communications() {
+    if (!this._communications) {
+      this._communications = new CommunicationsResource(this.http);
+    }
+    return this._communications;
+  }
+  /** Logged meetings — manual + provider-synced, with company matching (E55). */
+  get conversations() {
+    if (!this._conversations) {
+      this._conversations = new ConversationsResource(this.http);
+    }
+    return this._conversations;
+  }
+  get gmail() {
+    if (!this._gmail) {
+      this._gmail = new GmailResource(this.http);
+    }
+    return this._gmail;
+  }
+  get documents() {
+    if (!this._documents) {
+      this._documents = new DocumentsResource(this.http);
+    }
+    return this._documents;
+  }
   get tags() {
     if (!this._tags) {
       this._tags = new TagResource(this.http);
     }
     return this._tags;
   }
+  get tasks() {
+    if (!this._tasks) {
+      this._tasks = new TaskResource(this.http);
+    }
+    return this._tasks;
+  }
+  /** Record views — the "recently viewed" beacon + read (E41-F7). */
+  get recordViews() {
+    if (!this._recordViews) {
+      this._recordViews = new RecordViewsResource(this.http);
+    }
+    return this._recordViews;
+  }
+  /** Module status — which modules are active for the caller's tenant (E51-F1-S1). */
+  get modules() {
+    if (!this._modules) {
+      this._modules = new ModulesResource(this.http);
+    }
+    return this._modules;
+  }
+  /** The tenant's plan, billing status and plan ceiling — `plan.get()` (E54-F1-S2). */
+  get plan() {
+    if (!this._plan) {
+      this._plan = new PlanResource(this.http);
+    }
+    return this._plan;
+  }
+  /** The authenticated caller — `me.abilities()` (E52-F1-S3). */
+  get me() {
+    if (!this._me) {
+      this._me = new MeResource(this.http);
+    }
+    return this._me;
+  }
+  /** Settings → Roles, admin only — `roles.list/get/updateGrants/reset/history` (E52-F2-S5). */
+  get roles() {
+    if (!this._roles) {
+      this._roles = new RolesResource(this.http);
+    }
+    return this._roles;
+  }
+  /** Invoice settings — `invoiceSettings.getOfflineInstructions/setOfflineInstructions` (E56-F5-S4). */
+  get invoiceSettings() {
+    if (!this._invoiceSettings) {
+      this._invoiceSettings = new InvoiceSettingsResource(this.http);
+    }
+    return this._invoiceSettings;
+  }
+  /** Payment reminder settings, admin only — `invoiceReminders.list/update/preview` (E56-F8-S6). */
+  get invoiceReminders() {
+    if (!this._invoiceReminders) {
+      this._invoiceReminders = new InvoiceRemindersResource(this.http);
+    }
+    return this._invoiceReminders;
+  }
+  /** Published sequences a contact can be enrolled in (E51-F2-S6). */
+  get contactSequences() {
+    if (!this._contactSequences) {
+      this._contactSequences = new ContactSequencesResource(this.http);
+    }
+    return this._contactSequences;
+  }
+  /** Enroll a contact in a sequence, list its enrollments, exit one (E51-F2-S8). */
+  get enrollments() {
+    if (!this._enrollments) {
+      this._enrollments = new EnrollmentsResource(this.http);
+    }
+    return this._enrollments;
+  }
+  /** Tenant-readable workflow reads — a workflow version's ordered stages. */
+  get workflows() {
+    if (!this._workflows) {
+      this._workflows = new WorkflowsResource(this.http);
+    }
+    return this._workflows;
+  }
+  get serviceSchedules() {
+    if (!this._serviceSchedules) {
+      this._serviceSchedules = new ServiceSchedulesResource(this.http);
+    }
+    return this._serviceSchedules;
+  }
+  /**
+   * Recurring billing schedules (E56-F3) — CRUD, pause/resume/end, preview,
+   * the period ledger, Needs review, generate-now, skip and regenerate.
+   */
+  get billingSchedules() {
+    if (!this._billingSchedules) {
+      this._billingSchedules = new BillingScheduleResource(this.http);
+    }
+    return this._billingSchedules;
+  }
+  get customFields() {
+    if (!this._customFields) {
+      this._customFields = new CustomFieldsResource(this.http);
+    }
+    return this._customFields;
+  }
+  /** Ortto connector — list mappings, audiences, manual sync, sync status (E53). Admin-only. */
+  get ortto() {
+    if (!this._ortto) {
+      this._ortto = new OrttoResource(this.http);
+    }
+    return this._ortto;
+  }
   /**
    * Ergonomic webhook event router — `client.webhooks.on(pattern, handler)`
    * plus `client.webhooks.process({ body, signature, secret })`. Auth-independent
@@ -728,6 +2229,129 @@ var PlanesClient = class {
   }
 };
 
+// src/types/billing-schedule-types.ts
+var BILLING_CADENCES = ["weekly", "every_n_weeks", "monthly", "quarterly", "annually"];
+var BILLING_SCHEDULE_STATUSES = ["active", "paused", "ended"];
+var BILL_TIMINGS = ["in_advance", "in_arrears"];
+var BILLING_DELIVERY_MODES = ["auto_send", "draft_for_review"];
+var BILLING_COLLECTION_MODES = ["send_link", "autopay"];
+var AUTOPAY_UNAVAILABLE_REASONS = ["no_connect", "no_saved_method"];
+var BILLING_AUTOPAY_STATUSES = [
+  "not_applicable",
+  "scheduled",
+  "submitted",
+  "succeeded",
+  "failed",
+  "auth_required",
+  "retry_scheduled",
+  "abandoned"
+];
+var BILLING_BACKFILL_MODES = ["skip", "draft"];
+var BILLING_PERIOD_STATUSES = ["generated", "skipped", "needs_review", "failed", "voided"];
+var BILLING_PREVIEW_PERIOD_STATUSES = [...BILLING_PERIOD_STATUSES, "upcoming"];
+var BILLING_DELIVERY_STATUSES = ["pending", "sent", "failed", "not_applicable"];
+var BILLING_ADJUSTMENT_STATUSES = ["pending", "consumed", "cancelled"];
+var BILLING_ADJUSTMENT_TARGETS = ["next_invoice"];
+
+// src/types/contact-types.ts
+var CONTACT_SORT_KEYS = ["name", "created_at", "recent"];
+var CONTACT_LIST_INCLUDES = ["channels", "links"];
+
+// src/types/customer-types.ts
+var CUSTOMER_SORT_KEYS = ["created_at", "last_name", "first_name", "email", "phone", "source", "recent"];
+
+// src/types/opportunity-types.ts
+var OPPORTUNITY_SORT_KEYS = ["created_at", "total", "title", "customer_name", "stage", "priority", "recent"];
+var OPPORTUNITY_STATES = ["open", "closed", "won", "lost"];
+
+// src/types/job-types.ts
+var JOB_SORT_KEYS = ["created_at", "recent"];
+
+// src/types/estimate-types.ts
+var ESTIMATE_STATUSES = ["draft", "sent", "approved", "rejected"];
+
+// src/types/record-view-types.ts
+var RECORD_VIEW_ENTITY_TYPES = ["customer", "contact", "opportunity", "job"];
+
+// src/types/module-types.ts
+var MODULE_KEYS = [
+  "estimates",
+  "contracts",
+  "inventory",
+  "production",
+  "production_scheduling",
+  "calendar",
+  "service-schedules",
+  "marketplace",
+  "invoicing",
+  "knocks",
+  "accounting",
+  "contacts",
+  "tasks",
+  "comments",
+  "conversations"
+];
+
+// src/types/plan-types.ts
+var PLAN_KEYS = ["solo", "sales", "business", "operations", "legacy", "internal"];
+var BILLING_STATUSES = [
+  "trialing",
+  "active",
+  "past_due",
+  "unpaid",
+  "paused",
+  "canceled",
+  "comped"
+];
+var PLAN_SOURCES = ["stripe", "manual"];
+var BILLING_INTERVALS = ["month", "year"];
+var FEATURE_KEYS = [
+  "calendar",
+  "estimates",
+  "contracts",
+  "service_dispatch",
+  "production_scheduling",
+  "sub_management",
+  "reports",
+  "open_api",
+  "workflow_builder",
+  "integrations.quickbooks",
+  "integrations.stripe",
+  "integrations.hover",
+  "integrations.ortto",
+  "communications.marketing",
+  "ai.scheduling",
+  "ai.content_assist",
+  "ai.documents",
+  "ai.search",
+  "inventory_management",
+  "workflow_execution",
+  "marketplace"
+];
+
+// src/types/me-types.ts
+var AGENT_ROLES = [
+  "admin",
+  "sales",
+  "service",
+  "production",
+  "sub",
+  "readonly",
+  "system_agent"
+];
+
+// src/types/workflow-event-rule-types.ts
+var WORKFLOW_EVENT_RULE_EVENT_TYPES = [
+  "contract.status_changed",
+  "invoice.status_changed",
+  "calendar_event.status_changed",
+  /** "An event is booked": one-off events and recurring series masters. */
+  "calendar_event.created"
+];
+var WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES = [
+  "calendar_event.created"
+];
+
 // src/agent.ts
 import * as http from "http";
 function createActionServer(handlerMap, options) {
@@ -883,39 +2507,92 @@ function readBody(req) {
   });
 }
 export {
+  AGENT_ROLES,
+  AUTOPAY_UNAVAILABLE_REASONS,
   ActivityResource,
   AgentApp,
+  ApiResource,
   AuthenticationError,
   AuthorizationError,
+  BILLING_ADJUSTMENT_STATUSES,
+  BILLING_ADJUSTMENT_TARGETS,
+  BILLING_AUTOPAY_STATUSES,
+  BILLING_BACKFILL_MODES,
+  BILLING_CADENCES,
+  BILLING_COLLECTION_MODES,
+  BILLING_DELIVERY_MODES,
+  BILLING_DELIVERY_STATUSES,
+  BILLING_INTERVALS,
+  BILLING_PERIOD_STATUSES,
+  BILLING_PREVIEW_PERIOD_STATUSES,
+  BILLING_SCHEDULE_STATUSES,
+  BILLING_STATUSES,
+  BILL_TIMINGS,
   BaseResource,
+  BillingScheduleResource,
+  CONTACT_LIST_INCLUDES,
+  CONTACT_SORT_KEYS,
+  CUSTOMER_SORT_KEYS,
   CalendarEventResource,
+  CommunicationsResource,
   ContactChannelResource,
   ContactResource,
+  ContactSequencesResource,
   ContractResource,
+  ConversationsResource,
+  CustomFieldsResource,
   CustomerResource,
   DEFAULT_BASE_URL,
   DEFAULT_MAX_RETRIES,
   DEFAULT_TIMEOUT,
   DEFAULT_TOKEN_REFRESH_SKEW_MS,
+  DocumentsResource,
+  ESTIMATE_STATUSES,
+  EnrollmentsResource,
   EstimateResource,
+  FEATURE_KEYS,
+  GmailResource,
   InventoryResource,
+  InvoiceRemindersResource,
   InvoiceResource,
+  InvoiceSettingsResource,
+  JOB_SORT_KEYS,
   JobResource,
+  MODULE_KEYS,
+  MeResource,
   MemoryTokenStorage,
+  ModulesResource,
   NotFoundError,
   OAuthError,
+  OPPORTUNITY_SORT_KEYS,
+  OPPORTUNITY_STATES,
   OpportunityResource,
+  OrttoResource,
+  PLAN_KEYS,
+  PLAN_SOURCES,
+  PlanResource,
   Planes,
   PlanesClient,
   PlanesError,
   PropertyResource,
+  RECORD_VIEW_ENTITY_TYPES,
   RateLimitError,
+  RecordViewsResource,
+  RolesResource,
   ServerError,
+  ServiceSchedulesResource,
   TagResource,
+  TaskResource,
   ValidationError,
+  WEBHOOK_EVENT_TYPES,
+  WORKFLOW_EVENT_RULE_EVENT_TYPES,
+  WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES,
   WebhookRouter,
   WebhookVerificationError,
+  WorkflowEventRulesResource,
+  WorkflowsResource,
   buildAuthorizeUrl,
+  clientCredentialsGrant,
   createAgentApp,
   exchangeCode,
   parseWebhookEvent,