@planescrm/sdk 0.55.0 → 0.72.0

package/dist/index.js

@@ -73,6 +73,7 @@ __export(index_exports, {
   ESTIMATE_STATUSES: () => ESTIMATE_STATUSES,
   EnrollmentsResource: () => EnrollmentsResource,
   EstimateResource: () => EstimateResource,
+  EventAutomationsResource: () => EventAutomationsResource,
   FEATURE_KEYS: () => FEATURE_KEYS,
   GmailResource: () => GmailResource,
   InventoryResource: () => InventoryResource,
@@ -81,6 +82,8 @@ __export(index_exports, {
   InvoiceSettingsResource: () => InvoiceSettingsResource,
   JOB_SORT_KEYS: () => JOB_SORT_KEYS,
   JobResource: () => JobResource,
+  LeadSourcesResource: () => LeadSourcesResource,
+  ListsResource: () => ListsResource,
   MODULE_KEYS: () => MODULE_KEYS,
   MeResource: () => MeResource,
   MemoryTokenStorage: () => MemoryTokenStorage,
@@ -104,13 +107,20 @@ __export(index_exports, {
   RolesResource: () => RolesResource,
   ServerError: () => ServerError,
   ServiceSchedulesResource: () => ServiceSchedulesResource,
+  TASK_SORT_KEYS: () => TASK_SORT_KEYS,
   TagResource: () => TagResource,
   TaskResource: () => TaskResource,
+  TeamsResource: () => TeamsResource,
+  UsersResource: () => UsersResource,
   ValidationError: () => ValidationError,
   WEBHOOK_EVENT_TYPES: () => WEBHOOK_EVENT_TYPES,
+  WORKFLOW_EVENT_RULE_CATCH_UP_EVENT_TYPES: () => WORKFLOW_EVENT_RULE_CATCH_UP_EVENT_TYPES,
   WORKFLOW_EVENT_RULE_EVENT_TYPES: () => WORKFLOW_EVENT_RULE_EVENT_TYPES,
   WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES: () => WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES,
+  WebFormSubmissionsResource: () => WebFormSubmissionsResource,
+  WebFormsResource: () => WebFormsResource,
   WebhookRouter: () => WebhookRouter,
+  WebhookSubscriptionsResource: () => WebhookSubscriptionsResource,
   WebhookVerificationError: () => WebhookVerificationError,
   WorkflowEventRulesResource: () => WorkflowEventRulesResource,
   WorkflowsResource: () => WorkflowsResource,
@@ -292,6 +302,9 @@ var HttpClient = class {
     this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
     this.retryOnRateLimit = config.retryOnRateLimit !== false;
     this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.getAccessToken = config.getAccessToken;
+    this.onUnauthorized = config.onUnauthorized;
+    this.fetchImpl = config.fetch;
     if (config.clientId && config.clientSecret) {
       this.oauth = {
         clientId: config.clientId,
@@ -308,53 +321,68 @@ var HttpClient = class {
     let lastError;
     let didRefreshOn401 = false;
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const authHeaders = await this.resolveAuthHeaders();
       const headers = {
         "Content-Type": "application/json",
-        ...await this.resolveAuthHeaders(),
+        ...authHeaders,
         ...options.headers
       };
+      if (options.idempotencyKey) headers["Idempotency-Key"] = options.idempotencyKey;
+      const timer = timeoutSignal(this.timeout);
       const fetchOptions = {
         method: options.method,
         headers,
-        signal: AbortSignal.timeout(this.timeout)
+        signal: timer.signal
       };
       if (bodyStr !== void 0) {
         fetchOptions.body = bodyStr;
       }
-      const response = await fetch(url, fetchOptions);
-      if (response.ok) {
-        if (response.status === 204) {
-          return void 0;
+      try {
+        const response = await (this.fetchImpl ?? fetch)(url, fetchOptions);
+        if (response.ok) {
+          if (response.status === 204) {
+            return void 0;
+          }
+          if (options.responseType === "arrayBuffer") {
+            return await response.arrayBuffer();
+          }
+          return await response.json();
         }
-        if (options.responseType === "arrayBuffer") {
-          return await response.arrayBuffer();
+        if (response.status === 429 && this.retryOnRateLimit && attempt < this.maxRetries) {
+          const retryAfter = this.parseRetryAfter(response);
+          await this.sleep(retryAfter * 1e3);
+          continue;
         }
-        return await response.json();
-      }
-      if (response.status === 429 && this.retryOnRateLimit && attempt < this.maxRetries) {
-        const retryAfter = this.parseRetryAfter(response);
-        await this.sleep(retryAfter * 1e3);
-        continue;
-      }
-      if (response.status === 401 && this.oauth && !didRefreshOn401) {
-        didRefreshOn401 = true;
-        await this.refreshTokens();
-        attempt--;
-        continue;
-      }
-      lastError = await this.mapError(response);
-      if (response.status !== 429 || !this.retryOnRateLimit) {
-        throw lastError;
+        if (response.status === 401 && this.oauth && !didRefreshOn401) {
+          didRefreshOn401 = true;
+          await this.refreshTokens();
+          attempt--;
+          continue;
+        }
+        if (response.status === 401 && this.onUnauthorized && !didRefreshOn401) {
+          didRefreshOn401 = true;
+          if (await this.recoverSession(authHeaders["Authorization"])) {
+            attempt--;
+            continue;
+          }
+        }
+        lastError = await this.mapError(response);
+        if (response.status !== 429 || !this.retryOnRateLimit) {
+          throw lastError;
+        }
+      } finally {
+        timer.clear();
       }
     }
     throw lastError ?? new RateLimitError();
   }
   getAuthHeaders() {
+    if (this.getAccessToken) return {};
     if (this.accessToken) {
       return { Authorization: `Bearer ${this.accessToken}` };
     }
     if (this.apiKey) {
-      return { "X-API-Key": this.apiKey };
+      return { Authorization: `Bearer ${this.apiKey}` };
     }
     return {};
   }
@@ -365,6 +393,10 @@ var HttpClient = class {
    * the token is within the skew window of expiry.
    */
   async resolveAuthHeaders() {
+    if (this.getAccessToken) {
+      const token = await withTimeout(this.getAccessToken(), this.timeout, "getAccessToken");
+      return token ? { Authorization: `Bearer ${token}` } : {};
+    }
     if (!this.oauth) {
       return this.getAuthHeaders();
     }
@@ -428,6 +460,41 @@ var HttpClient = class {
       this.refreshInFlight = void 0;
     }
   }
+  /**
+   * Ask the app to refresh its session after a 401. Resolves `true` when the
+   * request should be retried.
+   * - Requests that got a 401 while a refresh is running share that one call.
+   * - A request whose 401 arrives after a refresh already finished (it was
+   *   sent with the old token) doesn't start a second refresh: if the current
+   *   token differs from the one it sent, it just retries with the new one.
+   * - A refresh that throws, or doesn't settle within the request timeout,
+   *   counts as "still signed out": the original 401 surfaces.
+   */
+  async recoverSession(sentAuthorization) {
+    if (!this.onUnauthorized || !this.getAccessToken) return false;
+    if (!this.unauthorizedInFlight) {
+      try {
+        const current = await withTimeout(this.getAccessToken(), this.timeout, "getAccessToken");
+        if (current && `Bearer ${current}` !== sentAuthorization) return true;
+      } catch {
+        return false;
+      }
+    }
+    if (!this.unauthorizedInFlight) {
+      const call = this.onUnauthorized;
+      const inFlight = (async () => {
+        try {
+          return await withTimeout(call(), this.timeout, "onUnauthorized");
+        } catch {
+          return false;
+        }
+      })().finally(() => {
+        if (this.unauthorizedInFlight === inFlight) this.unauthorizedInFlight = void 0;
+      });
+      this.unauthorizedInFlight = inFlight;
+    }
+    return this.unauthorizedInFlight;
+  }
   buildUrl(path, params) {
     const url = new URL(`${this.baseUrl}${path}`);
     if (params) {
@@ -455,7 +522,8 @@ var HttpClient = class {
       body = await response.json();
     } catch {
     }
-    const message = body["message"] ?? response.statusText ?? "Request failed";
+    const envelope = body["error"];
+    const message = (typeof body["message"] === "string" ? body["message"] : void 0) ?? (typeof envelope?.message === "string" ? envelope.message : void 0) ?? response.statusText ?? "Request failed";
     switch (response.status) {
       case 400: {
         const fieldErrors = body["errors"] ?? [];
@@ -482,6 +550,29 @@ var HttpClient = class {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
+function timeoutSignal(ms) {
+  if (typeof AbortSignal.timeout === "function") {
+    return { signal: AbortSignal.timeout(ms), clear: () => void 0 };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), ms);
+  return { signal: controller.signal, clear: () => clearTimeout(timer) };
+}
+function withTimeout(promise, ms, what) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${what} did not settle within ${ms}ms`)), ms);
+    Promise.resolve(promise).then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
 
 // src/resources/base-resource.ts
 var ApiResource = class {
@@ -511,13 +602,16 @@ var BaseResource = class extends ApiResource {
     });
   }
   /**
-   * Create a new entity.
+   * Create a new entity. Pass `idempotencyKey` (a UUID you keep for retries) to
+   * make a retry safe on routes that honor it (customers, opportunities, contacts,
+   * tasks): a repeat returns the first response and creates nothing.
    */
-  async create(data) {
+  async create(data, options) {
     return this.http.request({
       method: "POST",
       path: this.basePath,
-      body: data
+      body: data,
+      ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
     });
   }
   /**
@@ -547,6 +641,12 @@ function toQueryParams(params) {
   if (!params) return out;
   for (const [key, value] of Object.entries(params)) {
     if (value === void 0 || value === null) continue;
+    if (key === "customFields" && typeof value === "object" && !Array.isArray(value)) {
+      for (const [field, v] of Object.entries(value)) {
+        if (v !== void 0 && v !== null) out[`cf.${field}`] = String(v);
+      }
+      continue;
+    }
     if (Array.isArray(value)) {
       if (value.length === 0) continue;
       out[key] = value.map(String).join(",");
@@ -573,6 +673,16 @@ var OpportunityResource = class extends BaseResource {
       params: toQueryParams(params)
     });
   }
+  /**
+   * GET /opportunities/trade-options — the active trades a client can request
+   * (`requestedTradeIds` on create/update), sorted by name.
+   */
+  async tradeOptions() {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/trade-options`
+    });
+  }
   /** PUT /opportunities/{id} — partial update; stage moves go through workflow transitions. */
   async update(id, data) {
     return this.http.request({
@@ -581,6 +691,21 @@ var OpportunityResource = class extends BaseResource {
       body: data
     });
   }
+  /** GET /opportunities/:id/transitions — the pipeline moves available from the current stage, for the caller's role. */
+  async listTransitions(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}/transitions` });
+  }
+  /**
+   * POST /opportunities/:id/transition — take one pipeline move, as the stage button does: required
+   * fields are checked, the move is logged, and the stage's automations run (they can send email).
+   */
+  async transition(id, data) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/transition`, body: data });
+  }
+  /** GET /opportunities/:id/workflow — the pipeline instance with its transition history (404 if none). */
+  async getWorkflow(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}/workflow` });
+  }
 };
 
 // src/resources/customers.ts
@@ -627,6 +752,19 @@ var CustomerResource = class extends BaseResource {
       path: `/customers/${winnerId}/merge/${loserId}`
     });
   }
+  /**
+   * POST /customers/{id}/convert-to-company — turn a person customer into a
+   * company. The person becomes the company's primary contact (their email and
+   * phone, with do-not-contact and marketing opt-outs carried over). A customer
+   * that's already a company is a 409 `ALREADY_COMPANY`.
+   */
+  async convertToCompany(id, data = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/convert-to-company`,
+      body: data
+    });
+  }
 };
 
 // src/resources/properties.ts
@@ -665,6 +803,17 @@ var PropertyResource = class extends ApiResource {
       body: data
     });
   }
+  /** GET /customers/:customerId/properties/:id — one property, checked against its customer (404 if it isn't theirs). */
+  async getForCustomer(customerId, id) {
+    return this.http.request({
+      method: "GET",
+      path: `/customers/${customerId}/properties/${id}`
+    });
+  }
+  /** POST /properties/:id/geocode — queue a fresh geocode of the property's address. */
+  async geocode(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/geocode` });
+  }
   /** DELETE /customers/{customerId}/properties/{id} — soft delete (204). */
   async delete(customerId, id) {
     await this.http.request({
@@ -680,7 +829,11 @@ var CalendarEventResource = class extends BaseResource {
     super(http2, "/events");
   }
   async list(params) {
-    return super.list(params);
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params: params ?? {}
+    });
   }
   /**
    * PATCH /events/:id. For an occurrence of a recurring event, `editMode`
@@ -699,7 +852,8 @@ var CalendarEventResource = class extends BaseResource {
    * 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).
+   * skipped (none set, or `handled_by_pipeline_rule`: the pipeline's rule
+   * moves the record instead) or failed (with a reason).
    */
   async complete(id, body = {}) {
     return this.http.request({
@@ -708,6 +862,34 @@ var CalendarEventResource = class extends BaseResource {
       body
     });
   }
+  /**
+   * POST /events/:id/cancel. For an occurrence of a recurring event, `editMode`
+   * picks which occurrences are cancelled (`this` when omitted). 409 if already
+   * cancelled; 422 for a completed event.
+   */
+  async cancel(id, options = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/cancel`,
+      params: { recurrence_edit_mode: options.editMode }
+    });
+  }
+  /** POST /events/:id/participants — add a user, contact, crew or agent to the event. No invite is sent. */
+  async addParticipant(id, data) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/participants`,
+      body: data
+    });
+  }
+  /** PATCH /events/:id/participants/:participantId — set a participant's response. */
+  async updateParticipantStatus(id, participantId, status) {
+    return this.http.request({
+      method: "PATCH",
+      path: `${this.basePath}/${id}/participants/${participantId}`,
+      body: { status }
+    });
+  }
 };
 
 // src/resources/contracts.ts
@@ -715,6 +897,73 @@ var ContractResource = class extends BaseResource {
   constructor(http2) {
     super(http2, "/contracts");
   }
+  /** POST /contracts/for-subject — a bare agreement for a customer or a service schedule (no opportunity, no line groups). */
+  async createForSubject(data) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/for-subject`, body: data });
+  }
+  /** POST /contracts/flat — a contract on an opportunity with a manually entered total and a contract template, no estimates. */
+  async createFlat(data) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/flat`, body: data });
+  }
+  /** POST /contracts/{id}/change-orders — a change order on a signed or fulfilled contract (409 otherwise). */
+  async createChangeOrder(id, data) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/change-orders`,
+      body: data
+    });
+  }
+  /**
+   * GET /contracts/{id}/change-orders — the change orders written against a
+   * contract, oldest first, each with its line groups. A change order has none
+   * of its own, so asking for one returns an empty list.
+   */
+  async listChangeOrders(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}/change-orders`
+    });
+  }
+  /** POST /contracts/{id}/submit — submit for approval; auto-approved when under the tenant's threshold. */
+  async submit(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/submit` });
+  }
+  /** POST /contracts/{id}/approve — approve a contract pending approval (needs the approve grant). */
+  async approve(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/approve` });
+  }
+  /** POST /contracts/{id}/cancel — cancel a contract in any state before it's signed. */
+  async cancel(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/cancel` });
+  }
+  /** POST /contracts/{id}/reopen — return a kicked-back contract to draft for review and re-send. */
+  async reopen(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/reopen` });
+  }
+  /**
+   * POST /contracts/{id}/send — **emails the signer a "Review & Sign" link.**
+   * Snapshots the clauses and creates the signing token. An empty body
+   * addresses the customer; `signerContactId` sends it to that contact instead.
+   * The first send of a contract uses one unit of the tenant's e-signature
+   * allowance; a re-send doesn't. Not safe to retry blindly after a timeout: a
+   * repeat emails again.
+   */
+  async send(id, data = {}) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/send`, body: data });
+  }
+  /**
+   * GET /contracts/{id}/pdf — the contract PDF bytes. `type: 'signed'` returns
+   * the stored signed copy (404 until it's signed); otherwise a preview renders.
+   */
+  async downloadPdf(id, options = {}) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}/pdf`,
+      params: options.type ? { type: options.type } : {},
+      headers: { Accept: "application/pdf" },
+      responseType: "arrayBuffer"
+    });
+  }
 };
 
 // src/resources/jobs.ts
@@ -784,6 +1033,28 @@ var JobResource = class extends ApiResource {
       path: "/jobs/trade-coverage"
     });
   }
+  /** GET /jobs/{id}/workflow — the job's pipeline instance with its transition history (404 if none). */
+  async getWorkflow(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}/workflow` });
+  }
+  /**
+   * POST /jobs/{id}/transition — take one pipeline move, as the stage button
+   * does: required fields are checked, the move is logged, and **the
+   * transition's actions run**. A tenant can attach actions that create or send
+   * an invoice, charge a saved card, send a contract, or send email, SMS or a
+   * webhook. Not safe to retry blindly after a timeout: check `getWorkflow()`
+   * first, because a repeat runs the actions again.
+   */
+  async transition(id, data) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/transition`, body: data });
+  }
+  /** GET /jobs/{id}/transitions — the pipeline moves available from the job's current stage, for the caller's role. */
+  async listTransitions(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}/transitions`
+    });
+  }
 };
 
 // src/resources/estimates.ts
@@ -841,6 +1112,74 @@ var EstimateResource = class extends ApiResource {
       path: `/jobs/${jobId}/estimates/${id}`
     });
   }
+  /** GET /estimates/{id}/workflow — the estimate's pipeline instance with its transition history (404 if none). */
+  async getWorkflow(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}/workflow` });
+  }
+  /**
+   * POST /estimates/{id}/transition — take one pipeline move. **The
+   * transition's actions run**, as for `jobs.transition()`: a tenant can attach
+   * actions that bill, charge, send a contract, or send email, SMS or a webhook.
+   * Not safe to retry blindly after a timeout: check `getWorkflow()` first.
+   */
+  async transition(id, data) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/transition`, body: data });
+  }
+  /**
+   * PUT /jobs/{jobId}/estimates/{id}/status — move the estimate's status (see
+   * `UpdateEstimateStatusDto` for the allowed moves). The route itself sends
+   * nothing and creates no contract or invoice; a tenant's webhooks or
+   * automations on the status change can.
+   */
+  async updateStatus(jobId, id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/jobs/${jobId}/estimates/${id}/status`,
+      body: data
+    });
+  }
+  /** GET /estimates/{id}/transitions — the pipeline moves available from the estimate's current stage, for the caller's role. */
+  async listTransitions(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}/transitions`
+    });
+  }
+  /**
+   * POST /jobs/{jobId}/estimates/{estimateId}/line-items — add a line item. With
+   * `materialCatalogId` or `tradeLaborItemId`, the catalog fills in description,
+   * unit and price. The estimate's subtotal and total are recalculated.
+   */
+  async createLineItem(jobId, estimateId, data) {
+    return this.http.request({
+      method: "POST",
+      path: `/jobs/${jobId}/estimates/${estimateId}/line-items`,
+      body: data
+    });
+  }
+  /** PUT /jobs/{jobId}/estimates/{estimateId}/line-items/{id} — partial update; totals are recalculated. */
+  async updateLineItem(jobId, estimateId, id, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/jobs/${jobId}/estimates/${estimateId}/line-items/${id}`,
+      body: data
+    });
+  }
+  /** DELETE /jobs/{jobId}/estimates/{estimateId}/line-items/{id} — totals are recalculated. */
+  async deleteLineItem(jobId, estimateId, id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/jobs/${jobId}/estimates/${estimateId}/line-items/${id}`
+    });
+  }
+  /** PUT /jobs/{jobId}/estimates/{estimateId}/line-items/reorder — set each item's `sortOrder` (and optionally `section`) in one call. */
+  async reorderLineItems(jobId, estimateId, data) {
+    return this.http.request({
+      method: "PUT",
+      path: `/jobs/${jobId}/estimates/${estimateId}/line-items/reorder`,
+      body: data
+    });
+  }
 };
 
 // src/resources/invoices.ts
@@ -903,6 +1242,24 @@ var InvoiceResource = class extends BaseResource {
       params
     });
   }
+  /** GET /admin/invoices/{invoiceId}/payments — every payment recorded against the invoice (Read Payment). */
+  async listPayments(invoiceId) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${invoiceId}/payments`
+    });
+  }
+  /**
+   * GET /admin/payments/recording-settings — the tenant's resolved
+   * payment-recording settings (whether manual recording is on, and which
+   * methods). Read Invoice.
+   */
+  async getPaymentRecordingSettings() {
+    return this.http.request({
+      method: "GET",
+      path: "/admin/payments/recording-settings"
+    });
+  }
   /** GET /admin/invoices/overdue/summary — `{ count, total }` of every overdue invoice. Read Invoice. */
   async overdueSummary() {
     return this.http.request({
@@ -932,33 +1289,72 @@ var InventoryResource = class extends BaseResource {
       body: data
     });
   }
+  // ---- Material used on a job (E64-S9). The routes live under /jobs/{jobId}. ----
+  /**
+   * POST /jobs/{jobId}/consumption — record stock drawn from a location for a
+   * job. Each line lowers that location's on-hand quantity.
+   */
+  async recordJobConsumption(jobId, data) {
+    return this.http.request({
+      method: "POST",
+      path: `/jobs/${jobId}/consumption`,
+      body: data
+    });
+  }
+  /**
+   * GET /jobs/{jobId}/consumption — one page of the job's consume and return
+   * movements (newest first by default), the job's totals across every page,
+   * and page metadata. The rows are under `items`, not `data`.
+   */
+  async listJobConsumption(jobId, params) {
+    return this.http.request({
+      method: "GET",
+      path: `/jobs/${jobId}/consumption`,
+      params: toQueryParams(params)
+    });
+  }
+  /** POST /jobs/{jobId}/return — put unused stock from a job back into a location. */
+  async returnFromJob(jobId, data) {
+    return this.http.request({
+      method: "POST",
+      path: `/jobs/${jobId}/return`,
+      body: data
+    });
+  }
+  /** GET /jobs/{jobId}/material-variance — estimated vs actual material for the job. */
+  async getJobMaterialVariance(jobId) {
+    return this.http.request({
+      method: "GET",
+      path: `/jobs/${jobId}/material-variance`
+    });
+  }
 };
 
 // src/resources/contacts.ts
 var ContactChannelResource = class {
   constructor(http2, contactId) {
     this.http = http2;
-    this.basePath = `/contacts/${contactId}/channels`;
+    this.contactId = contactId;
   }
   /** Returns `{ channel, duplicateOf }` — `duplicateOf` is the dedup signal. */
   async create(data) {
     return this.http.request({
       method: "POST",
-      path: this.basePath,
+      path: `/contacts/${this.contactId}/channels`,
       body: data
     });
   }
   async update(channelId, data) {
     return this.http.request({
       method: "PATCH",
-      path: `${this.basePath}/${channelId}`,
+      path: `/contacts/${this.contactId}/channels/${channelId}`,
       body: data
     });
   }
   async delete(channelId) {
     await this.http.request({
       method: "DELETE",
-      path: `${this.basePath}/${channelId}`
+      path: `/contacts/${this.contactId}/channels/${channelId}`
     });
   }
 };
@@ -986,6 +1382,46 @@ var ContactResource = class extends BaseResource {
       path: `/contacts/${winnerId}/merge/${loserId}`
     });
   }
+  /** GET /contacts/roles — the distinct roles in use on active links, for a role picker. */
+  async listRoles() {
+    return this.http.request({ method: "GET", path: "/contacts/roles" });
+  }
+  /** GET /contacts/:id/links — every link, active and ended (history). `get()` returns active links only. */
+  async listLinks(contactId) {
+    return this.http.request({ method: "GET", path: `/contacts/${contactId}/links` });
+  }
+  /** POST /contacts/:id/links — link the contact to a customer or property. */
+  async addLink(contactId, data) {
+    return this.http.request({ method: "POST", path: `/contacts/${contactId}/links`, body: data });
+  }
+  /** PATCH /contacts/:id/links/:linkId — change role/primary, or end the link (`endedAt`). */
+  async updateLink(contactId, linkId, data) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/contacts/${contactId}/links/${linkId}`,
+      body: data
+    });
+  }
+  /** POST /contacts/:id/workflow/start — opt the contact into the relationship pipeline (409 if started). */
+  async startWorkflow(contactId) {
+    return this.http.request({ method: "POST", path: `/contacts/${contactId}/workflow/start` });
+  }
+  /** GET /contacts/:id/workflow — current stage and the transitions available from it. */
+  async getWorkflow(contactId) {
+    return this.http.request({ method: "GET", path: `/contacts/${contactId}/workflow` });
+  }
+  /** POST /contacts/:id/workflow/transitions/:transitionId — 422 for an invalid move or unmet required fields. */
+  async transition(contactId, transitionId) {
+    return this.http.request({
+      method: "POST",
+      path: `/contacts/${contactId}/workflow/transitions/${transitionId}`,
+      body: {}
+    });
+  }
+  /** GET /contacts/:id/workflow/history */
+  async getWorkflowHistory(contactId) {
+    return this.http.request({ method: "GET", path: `/contacts/${contactId}/workflow/history` });
+  }
   channels(contactId) {
     return new ContactChannelResource(this.http, contactId);
   }
@@ -1232,6 +1668,14 @@ var TagResource = class extends ApiResource {
   async delete(id) {
     await this.http.request({ method: "DELETE", path: `${this.basePath}/${id}` });
   }
+  /**
+   * POST /tags/:winnerId/merge/:loserId — fold a duplicate tag into another: records
+   * move to the winner (`retagged`), duplicates are dropped (`dropped`), and the
+   * loser is deleted. Irreversible.
+   */
+  async merge(winnerId, loserId) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${winnerId}/merge/${loserId}` });
+  }
   /** `TagsService.setEntityTags()` returns the final tag set wrapped in `{ tags }`. */
   async setEntityTags(entityType, entityId, data) {
     return this.http.request({
@@ -1240,6 +1684,31 @@ var TagResource = class extends ApiResource {
       body: data
     });
   }
+  /**
+   * POST /entities/:type/:id/tags — add ONE tag, keeping the record's other tags.
+   * Safe to call concurrently with other tag changes on the same record (unlike
+   * read-modify-write through `setEntityTags()`). Adding a tag the record already
+   * carries is a no-op. Returns the record's full tag set.
+   */
+  async addEntityTag(entityType, entityId, ref) {
+    const body = ref.tagId !== void 0 ? { tag_id: ref.tagId } : { tag_name: ref.tagName };
+    return this.http.request({
+      method: "POST",
+      path: `/entities/${entityType}/${entityId}/tags`,
+      body
+    });
+  }
+  /**
+   * DELETE /entities/:type/:id/tags/:tagId — remove ONE tag, keeping the rest.
+   * Removing a tag the record doesn't carry is a no-op. Returns the record's
+   * full tag set.
+   */
+  async removeEntityTag(entityType, entityId, tagId) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/entities/${entityType}/${entityId}/tags/${tagId}`
+    });
+  }
   async getEntityTags(entityType, entityId) {
     return this.http.request({
       method: "GET",
@@ -1255,6 +1724,111 @@ var TagResource = class extends ApiResource {
   }
 };
 
+// src/resources/lists.ts
+var ListsResource = class extends ApiResource {
+  constructor(http2) {
+    super(http2, "/lists");
+  }
+  /** GET /lists — every list, newest first, each with `member_count`. A bare array. */
+  async list() {
+    return this.http.request({ method: "GET", path: this.basePath });
+  }
+  /**
+   * GET /lists/filter-fields — the standard fields, their types and the operators
+   * each accepts for a smart list of this entity type, and whether custom fields
+   * are accepted (E66-S3). A save that breaks these rules is a 400.
+   */
+  async filterFields(entityType) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/filter-fields`,
+      params: { entity_type: entityType }
+    });
+  }
+  /** GET /lists/:id — one list with an on-demand `member_count`. */
+  async get(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}` });
+  }
+  /** POST /lists */
+  async create(data) {
+    return this.http.request({ method: "POST", path: this.basePath, body: data });
+  }
+  /** PATCH /lists/:id — rename, or replace a smart list's definition. */
+  async update(id, data) {
+    return this.http.request({ method: "PATCH", path: `${this.basePath}/${id}`, body: data });
+  }
+  /** DELETE /lists/:id — soft delete; the records on the list are untouched. */
+  async delete(id) {
+    await this.http.request({ method: "DELETE", path: `${this.basePath}/${id}` });
+  }
+  /** POST /lists/:id/members — static lists only; idempotent on duplicates. */
+  async addMembers(id, members) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/members`,
+      body: { members }
+    });
+  }
+  /** DELETE /lists/:id/members — static lists only. */
+  async removeMembers(id, members) {
+    return this.http.request({
+      method: "DELETE",
+      path: `${this.basePath}/${id}/members`,
+      body: { members }
+    });
+  }
+  /** GET /lists/:id/recipients — people (audience, contact and customer lists), with consent. */
+  async getRecipients(id, params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}/recipients`,
+      params
+    });
+  }
+  /** POST /lists/:id/export — queues a CSV export; a notification links the file when it's ready. */
+  async export(id, options) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/export`,
+      body: options ?? {}
+    });
+  }
+};
+
+// src/resources/lead-sources.ts
+var LeadSourcesResource = class extends ApiResource {
+  constructor(http2) {
+    super(http2, "/lead-sources");
+  }
+  /** GET /lead-sources — active ones by default, in display order. */
+  async list(options) {
+    const res = await this.http.request({
+      method: "GET",
+      path: this.basePath,
+      ...options?.includeInactive ? { params: { includeInactive: "true" } } : {}
+    });
+    return res.data;
+  }
+  /** POST /lead-sources — 409 on a duplicate key. */
+  async create(data) {
+    const res = await this.http.request({ method: "POST", path: this.basePath, body: data });
+    return res.data;
+  }
+  /** PATCH /lead-sources/:id — label, active flag or order; the key can't change. */
+  async update(id, data) {
+    const res = await this.http.request({
+      method: "PATCH",
+      path: `${this.basePath}/${id}`,
+      body: data
+    });
+    return res.data;
+  }
+  /** DELETE /lead-sources/:id — soft delete. */
+  async delete(id) {
+    await this.http.request({ method: "DELETE", path: `${this.basePath}/${id}` });
+  }
+};
+
 // src/resources/tasks.ts
 var TaskResource = class extends ApiResource {
   constructor(http2) {
@@ -1271,9 +1845,14 @@ var TaskResource = class extends ApiResource {
   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 });
+  /** POST /tasks. Pass `idempotencyKey` to make a retry safe (E64-S6). */
+  async create(data, options) {
+    return this.http.request({
+      method: "POST",
+      path: this.basePath,
+      body: data,
+      ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
+    });
   }
   /** PATCH /tasks/:id — non-terminal fields only; terminal status changes use the action methods. */
   async update(id, data) {
@@ -1468,70 +2047,220 @@ var InvoiceSettingsResource = class {
       path: `${this.basePath}/overdue-offsets`,
       body
     });
-    return res.offsets;
+    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/event-automations.ts
+var EventAutomationsResource = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  // 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 — enabled and disabled automations, oldest first, optionally by event type or owner. */
+  async list(params = {}) {
+    const query = {};
+    if (params.owner_tag) query["owner_tag"] = params.owner_tag;
+    if (params.event_type) query["event_type"] = params.event_type;
+    const res = await this.http.request({
+      method: "GET",
+      path: "/admin/event-automations",
+      params: query
+    });
+    return res.data;
+  }
+  /** GET /:id — 404 when it doesn't exist or was deleted. */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `/admin/event-automations/${encodeURIComponent(id)}`
+    });
+  }
+  /**
+   * POST — create (201). 400 `VALIDATION_FAILED` for a bad body, or a 400
+   * naming the step whose `action_type` isn't allowed in automations.
+   */
+  async create(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/admin/event-automations",
+      body: input
+    });
   }
   /**
-   * GET /admin/invoice-settings/attach-pdf — whether invoice emails carry the
-   * invoice PDF (on unless an admin turned it off).
+   * PATCH /:id — only the fields sent change. Sending `actions` replaces the
+   * list: keep each existing step's `id` so a step that already ran isn't run
+   * again. `{ enabled: false }` switches it off.
    */
-  async getAttachPdf() {
-    const res = await this.http.request({
-      method: "GET",
-      path: `${this.basePath}/attach-pdf`
+  async update(id, input) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/admin/event-automations/${encodeURIComponent(id)}`,
+      body: input
     });
-    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
+  /** DELETE /:id — soft delete; returns `{ id }` (200). */
+  async delete(id) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/admin/event-automations/${encodeURIComponent(id)}`
     });
-    return res.enabled;
   }
 };
 
-// src/resources/invoice-reminders.ts
-var InvoiceRemindersResource = class {
+// src/resources/web-forms.ts
+var WebFormsResource = class {
   constructor(http2) {
     this.http = http2;
-    this.basePath = "/admin/invoice-reminders";
+    this.submissions = new WebFormSubmissionsResource(http2);
   }
-  /** GET /admin/invoice-reminders — the rules, ascending by offset, and the overdue offsets. */
+  // Each request spells its path out in full so the API's SDK route-parity
+  // audit (sdk-route-parity-audit.spec.ts) can read it.
+  /** GET — every form not archived, newest first. */
   async list() {
+    const res = await this.http.request({ method: "GET", path: "/admin/web-forms" });
+    return res.data;
+  }
+  /** GET /trade-options — the active trades a `trade` question offers, by current name. */
+  async tradeOptions() {
+    const res = await this.http.request({ method: "GET", path: "/admin/web-forms/trade-options" });
+    return res.data;
+  }
+  /** GET /:id */
+  async get(id) {
+    return this.http.request({ method: "GET", path: `/admin/web-forms/${encodeURIComponent(id)}` });
+  }
+  /** POST — create (201) with its default routing. Pass `recipient_agent_ids`. */
+  async create(input) {
+    return this.http.request({ method: "POST", path: "/admin/web-forms", body: input });
+  }
+  /** PATCH /:id — only the fields sent change. `active: false` switches the form off. */
+  async update(id, input) {
     return this.http.request({
-      method: "GET",
-      path: this.basePath
+      method: "PATCH",
+      path: `/admin/web-forms/${encodeURIComponent(id)}`,
+      body: input
     });
   }
-  /**
-   * 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) {
+  /** DELETE /:id — archive: the public URL stops working and routing stops. Returns `{ id }`. */
+  async archive(id) {
+    return this.http.request({ method: "DELETE", path: `/admin/web-forms/${encodeURIComponent(id)}` });
+  }
+  /** POST /:id/rotate-key — a new public key; the old embed stops working at once. */
+  async rotateKey(id) {
     return this.http.request({
-      method: "PUT",
-      path: this.basePath,
-      body: { rules }
+      method: "POST",
+      path: `/admin/web-forms/${encodeURIComponent(id)}/rotate-key`
     });
   }
+};
+var WebFormSubmissionsResource = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  /** GET /submissions — the first page, newest first, with routing state. Use `listPage` to read on. */
+  async list(params = {}) {
+    return (await this.listPage(params)).data;
+  }
   /**
-   * POST /admin/invoice-reminders/preview — render a subject and body exactly
-   * as the reminder email would, against an invoice or a sample. Sends nothing.
+   * GET /submissions — one page plus `next`, which is null on the last page.
+   * Pass `next`'s `before` and `before_id` back in to read the following page.
    */
-  async preview(params) {
+  async listPage(params = {}) {
+    const query = {};
+    for (const [k, v] of Object.entries(params)) if (v !== void 0) query[k] = v;
+    const res = await this.http.request({
+      method: "GET",
+      path: "/admin/web-forms/submissions",
+      params: query
+    });
+    return { data: res.data, next: res.next ?? null };
+  }
+  /** GET /submissions/:id — answers as seen, plus each routing step. */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `/admin/web-forms/submissions/${encodeURIComponent(id)}`
+    });
+  }
+  /** PATCH /submissions/:id — set triage status. */
+  async update(id, input) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/admin/web-forms/submissions/${encodeURIComponent(id)}`,
+      body: input
+    });
+  }
+  /** POST /submissions/:id/route — retry failed steps, run never-run ones (not email, text or webhook: `skipped`); safe to repeat. */
+  async route(id) {
     return this.http.request({
       method: "POST",
-      path: `${this.basePath}/preview`,
-      body: params
+      path: `/admin/web-forms/submissions/${encodeURIComponent(id)}/route`
     });
   }
 };
@@ -1703,23 +2432,119 @@ var WorkflowsResource = class {
 var ServiceSchedulesResource = class {
   constructor(http2) {
     this.http = http2;
-    this.basePath = "/service-schedules";
+  }
+  // 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 — the schedules of one customer or opportunity. */
+  async list(subject_type, subject_id) {
+    return this.http.request({
+      method: "GET",
+      path: "/service-schedules",
+      params: { subject_type, subject_id }
+    });
+  }
+  /** GET /:id — 404 when it doesn't exist or was deleted. */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `/service-schedules/${encodeURIComponent(id)}`
+    });
+  }
+  /**
+   * POST — create (201). The horizon's visits are generated straight away.
+   * 400 `INVALID_RECURRENCE_RULE`, `SERVICE_TRADE_REQUIRED` or a validation error.
+   */
+  async create(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/service-schedules",
+      body: input
+    });
+  }
+  /**
+   * PATCH /:id — only the fields sent change. A cadence, time, crew, duration
+   * or horizon change regenerates future visits from today (`effective_from`,
+   * which must be today) and reports it in `regeneration`; a visit someone changed is never
+   * touched and is listed under `regeneration.protected`. The edit and its
+   * regeneration succeed or fail together. 400 `INVALID_EFFECTIVE_FROM` for any
+   * date but today.
+   */
+  async update(id, input) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/service-schedules/${encodeURIComponent(id)}`,
+      body: input
+    });
+  }
+  /** POST /:id/preview-update — what `update` with the same input would do. Writes nothing. */
+  async previewUpdate(id, input) {
+    return this.http.request({
+      method: "POST",
+      path: `/service-schedules/${encodeURIComponent(id)}/preview-update`,
+      body: input
+    });
+  }
+  /** PATCH /:id/status — pause, resume (`active`) or end. Resume generates the horizon at once. */
+  async setStatus(id, status) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/service-schedules/${encodeURIComponent(id)}/status`,
+      body: { status }
+    });
+  }
+  /** DELETE /:id — soft-delete (204). */
+  async delete(id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/service-schedules/${encodeURIComponent(id)}`
+    });
   }
   /**
-   * 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).
+   * POST /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`,
+      path: "/service-schedules/conflicts/preview",
       body: request
     });
   }
+  /** GET /settings/crew-roles — which agent roles count as assignable crew. */
+  async getCrewRoles() {
+    return this.http.request({
+      method: "GET",
+      path: "/service-schedules/settings/crew-roles"
+    });
+  }
+  /** PUT /settings/crew-roles — set the assignable roles (an override of the default). */
+  async setCrewRoles(roles) {
+    return this.http.request({
+      method: "PUT",
+      path: "/service-schedules/settings/crew-roles",
+      body: { roles }
+    });
+  }
+  /** GET /settings/crew — assignable crew with their home-base status. */
+  async listCrew() {
+    const res = await this.http.request({
+      method: "GET",
+      path: "/service-schedules/settings/crew"
+    });
+    return res.crew;
+  }
+  /** PUT /settings/crew/:agentId/home-address — set and geocode a crew member's home base. */
+  async setCrewHomeAddress(agentId, address) {
+    return this.http.request({
+      method: "PUT",
+      path: `/service-schedules/settings/crew/${encodeURIComponent(agentId)}/home-address`,
+      body: { address }
+    });
+  }
 };
 
 // src/resources/billing-schedules.ts
@@ -1924,6 +2749,52 @@ var CustomFieldsResource = class {
       params
     });
   }
+  /** GET /admin/custom-fields — the same list through the admin route (Manage grant). */
+  async listAll(params) {
+    return this.http.request({
+      method: "GET",
+      path: "/admin/custom-fields",
+      params
+    });
+  }
+  /** GET /admin/custom-fields/:id */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `/admin/custom-fields/${id}`
+    });
+  }
+  /**
+   * POST /admin/custom-fields — define a new field. 400 for `job`, `vendor` or
+   * `agent` (those records can't hold values yet, PRD D6). A `fieldKey` must be
+   * unique per entity type: check `listAll({ entity_type, include_inactive: true })` first.
+   */
+  async create(data) {
+    return this.http.request({
+      method: "POST",
+      path: "/admin/custom-fields",
+      body: data
+    });
+  }
+  /** PATCH /admin/custom-fields/:id — `fieldKey` and `entityType` can't change. */
+  async update(id, data) {
+    return this.http.request({
+      method: "PATCH",
+      path: `/admin/custom-fields/${id}`,
+      body: data
+    });
+  }
+  /**
+   * DELETE /admin/custom-fields/:id — deactivates the definition (204). Records
+   * keep their stored values; `list({ include_inactive: true })` still shows it,
+   * and `update(id, { active: true })` brings it back.
+   */
+  async deactivate(id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/admin/custom-fields/${id}`
+    });
+  }
 };
 
 // src/resources/ortto.ts
@@ -1999,6 +2870,121 @@ var OrttoResource = class {
   }
 };
 
+// src/resources/webhook-subscriptions.ts
+var WebhookSubscriptionsResource = class extends ApiResource {
+  constructor(http2) {
+    super(http2, "/admin/webhooks");
+  }
+  /** POST /admin/webhooks — the returned `secret` is shown only this once. */
+  async create(data) {
+    return this.http.request({ method: "POST", path: this.basePath, body: data });
+  }
+  /** GET /admin/webhooks */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params
+    });
+  }
+  /** GET /admin/webhooks/:id */
+  async get(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}` });
+  }
+  /** PATCH /admin/webhooks/:id */
+  async update(id, data) {
+    return this.http.request({ method: "PATCH", path: `${this.basePath}/${id}`, body: data });
+  }
+  /** DELETE /admin/webhooks/:id */
+  async delete(id) {
+    return this.http.request({ method: "DELETE", path: `${this.basePath}/${id}` });
+  }
+  /** POST /admin/webhooks/:id/test — sends one signed test event to the URL now. */
+  async test(id) {
+    return this.http.request({ method: "POST", path: `${this.basePath}/${id}/test` });
+  }
+  /**
+   * POST /admin/webhooks/:id/rotate-secret — replaces the signing secret and
+   * returns the new one, shown only this once. New deliveries are signed with
+   * it, but deliveries already queued (and their retries, for several minutes)
+   * keep the old one. `verifyWebhookSignature` checks one secret, so for a few
+   * minutes have your receiver try the new secret and fall back to the old one.
+   */
+  async rotateSecret(id) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/rotate-secret`
+    });
+  }
+  /** GET /admin/webhooks/:id/deliveries — newest first. */
+  async listDeliveries(id, params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}/deliveries`,
+      params
+    });
+  }
+  /**
+   * POST /admin/webhooks/:id/deliveries/:deliveryId/retry — queues a new
+   * delivery of that event (202). The receiver sees the event again, so make
+   * it idempotent on the event id.
+   */
+  async retryDelivery(id, deliveryId) {
+    return this.http.request({
+      method: "POST",
+      path: `${this.basePath}/${id}/deliveries/${deliveryId}/retry`
+    });
+  }
+};
+
+// src/resources/users.ts
+var UsersResource = class extends ApiResource {
+  constructor(http2) {
+    super(http2, "/users");
+  }
+  /** GET /users — paged, with email, role, status and org fields (read grant on users). */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params
+    });
+  }
+  /**
+   * GET /users/directory — active users' ids, names and roles, for pickers and
+   * for resolving an assignee. Every role can read it.
+   */
+  async directory(params) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/directory`,
+      params
+    });
+  }
+  /**
+   * GET /users/:id/working-hours — the user's own weekly hours and the tenant
+   * default. A non-admin caller may read only their own (403 otherwise).
+   */
+  async getWorkingHours(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}/working-hours` });
+  }
+};
+
+// src/resources/teams.ts
+var TeamsResource = class extends ApiResource {
+  constructor(http2) {
+    super(http2, "/teams");
+  }
+  /** GET /teams — every team, with `member_count`. */
+  async list() {
+    return this.http.request({ method: "GET", path: this.basePath });
+  }
+  /** GET /teams/:id — one team, with `members`. */
+  async get(id) {
+    return this.http.request({ method: "GET", path: `${this.basePath}/${id}` });
+  }
+};
+
 // src/webhooks.ts
 var import_node_crypto2 = require("crypto");
 var WEBHOOK_EVENT_TYPES = [
@@ -2034,7 +3020,8 @@ var WEBHOOK_EVENT_TYPES = [
   "integration_connection.deactivated",
   "customer_payment_method.invalidated",
   "invoice.autopay_succeeded",
-  "invoice.autopay_failed"
+  "invoice.autopay_failed",
+  "received"
 ];
 function verifyWebhookSignature(payload, signature, secret) {
   if (!signature || !secret || !payload) {
@@ -2236,6 +3223,18 @@ var PlanesClient = class {
     }
     return this._tags;
   }
+  get lists() {
+    if (!this._lists) {
+      this._lists = new ListsResource(this.http);
+    }
+    return this._lists;
+  }
+  get leadSources() {
+    if (!this._leadSources) {
+      this._leadSources = new LeadSourcesResource(this.http);
+    }
+    return this._leadSources;
+  }
   get tasks() {
     if (!this._tasks) {
       this._tasks = new TaskResource(this.http);
@@ -2291,6 +3290,20 @@ var PlanesClient = class {
     }
     return this._invoiceReminders;
   }
+  /** Event automations, admin only — `eventAutomations.list/get/create/update/delete` (E60-S2). */
+  get eventAutomations() {
+    if (!this._eventAutomations) {
+      this._eventAutomations = new EventAutomationsResource(this.http);
+    }
+    return this._eventAutomations;
+  }
+  /** Web forms and their submissions, admin only — `webForms.list/get/create/update/archive/rotateKey`, `webForms.submissions.list/get/update/route` (E60-S6). */
+  get webForms() {
+    if (!this._webForms) {
+      this._webForms = new WebFormsResource(this.http);
+    }
+    return this._webForms;
+  }
   /** Published sequences a contact can be enrolled in (E51-F2-S6). */
   get contactSequences() {
     if (!this._contactSequences) {
@@ -2341,6 +3354,30 @@ var PlanesClient = class {
     }
     return this._ortto;
   }
+  /**
+   * Webhook subscriptions — where entity events are delivered (E64-S10). Admin
+   * grants and the `open_api` feature. Not `webhooks`: that is the event router.
+   */
+  get webhookSubscriptions() {
+    if (!this._webhookSubscriptions) {
+      this._webhookSubscriptions = new WebhookSubscriptionsResource(this.http);
+    }
+    return this._webhookSubscriptions;
+  }
+  /** The tenant's users, read-only: list and directory (E64-S10). */
+  get users() {
+    if (!this._users) {
+      this._users = new UsersResource(this.http);
+    }
+    return this._users;
+  }
+  /** Teams, read-only (E64-S10). */
+  get teams() {
+    if (!this._teams) {
+      this._teams = new TeamsResource(this.http);
+    }
+    return this._teams;
+  }
   /**
    * Ergonomic webhook event router — `client.webhooks.on(pattern, handler)`
    * plus `client.webhooks.process({ body, signature, secret })`. Auth-independent
@@ -2380,14 +3417,14 @@ 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_SORT_KEYS = ["name", "created_at", "recent", "updated_at"];
 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"];
+var CUSTOMER_SORT_KEYS = ["created_at", "last_name", "first_name", "email", "phone", "source", "recent", "updated_at"];
 
 // src/types/opportunity-types.ts
-var OPPORTUNITY_SORT_KEYS = ["created_at", "total", "title", "customer_name", "stage", "priority", "recent"];
+var OPPORTUNITY_SORT_KEYS = ["created_at", "total", "title", "customer_name", "stage", "priority", "recent", "updated_at"];
 var OPPORTUNITY_STATES = ["open", "closed", "won", "lost"];
 
 // src/types/job-types.ts
@@ -2415,7 +3452,8 @@ var MODULE_KEYS = [
   "contacts",
   "tasks",
   "comments",
-  "conversations"
+  "conversations",
+  "web_forms"
 ];
 
 // src/types/plan-types.ts
@@ -2477,6 +3515,12 @@ var WORKFLOW_EVENT_RULE_EVENT_TYPES = [
 var WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES = [
   "calendar_event.created"
 ];
+var WORKFLOW_EVENT_RULE_CATCH_UP_EVENT_TYPES = [
+  "calendar_event.created"
+];
+
+// src/types/task-types.ts
+var TASK_SORT_KEYS = ["due_at", "created_at", "updated_at"];
 
 // src/agent.ts
 var http = __toESM(require("http"));
@@ -2677,6 +3721,7 @@ function readBody(req) {
   ESTIMATE_STATUSES,
   EnrollmentsResource,
   EstimateResource,
+  EventAutomationsResource,
   FEATURE_KEYS,
   GmailResource,
   InventoryResource,
@@ -2685,6 +3730,8 @@ function readBody(req) {
   InvoiceSettingsResource,
   JOB_SORT_KEYS,
   JobResource,
+  LeadSourcesResource,
+  ListsResource,
   MODULE_KEYS,
   MeResource,
   MemoryTokenStorage,
@@ -2708,13 +3755,20 @@ function readBody(req) {
   RolesResource,
   ServerError,
   ServiceSchedulesResource,
+  TASK_SORT_KEYS,
   TagResource,
   TaskResource,
+  TeamsResource,
+  UsersResource,
   ValidationError,
   WEBHOOK_EVENT_TYPES,
+  WORKFLOW_EVENT_RULE_CATCH_UP_EVENT_TYPES,
   WORKFLOW_EVENT_RULE_EVENT_TYPES,
   WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES,
+  WebFormSubmissionsResource,
+  WebFormsResource,
   WebhookRouter,
+  WebhookSubscriptionsResource,
   WebhookVerificationError,
   WorkflowEventRulesResource,
   WorkflowsResource,